diff --git a/crates/horizon-world/src/level/data.rs b/crates/horizon-world/src/level/data.rs index cbee85ebc..cce3249dc 100644 --- a/crates/horizon-world/src/level/data.rs +++ b/crates/horizon-world/src/level/data.rs @@ -550,6 +550,7 @@ props! { orientation = "orientation", crafting = "crafting", side_chain = "side_chain", + copper_golem_pose = "copper_golem_pose", } fn fail(message: &str) -> io::Error { diff --git a/crates/horizon-world/src/level/fluids.rs b/crates/horizon-world/src/level/fluids.rs new file mode 100644 index 000000000..116310476 --- /dev/null +++ b/crates/horizon-world/src/level/fluids.rs @@ -0,0 +1,599 @@ +//! `FlowingFluid` (water and lava) ticking and spreading, `LiquidBlock` +//! interactions, liquid containers (waterlogging) and bucket pickup. +use super::{ + Dimension, LevelAccess, Sim, + classes::{Class, Interface}, + update::{HORIZONTAL, above, below, rel}, +}; +use crate::{ + fluid::{FluidKind, FluidState}, + registry::BlockStateId, +}; +use horizon_core::{ + geometry::{Axis, Direction, ShapeOp, VoxelShape}, + position::BlockPos, + random::RandomSource, +}; +use std::collections::HashMap; + +/// `LiquidBlock.POSSIBLE_FLOW_DIRECTIONS`. +const POSSIBLE_FLOW_DIRECTIONS: [Direction; 5] = [ + Direction::Down, + Direction::South, + Direction::North, + Direction::East, + Direction::West, +]; + +fn is_water(kind: FluidKind) -> bool { + matches!(kind, FluidKind::Water | FluidKind::FlowingWater) +} +fn source_of(kind: FluidKind) -> FluidKind { + if is_water(kind) { FluidKind::Water } else { FluidKind::Lava } +} +fn flowing_of(kind: FluidKind) -> FluidKind { + if is_water(kind) { FluidKind::FlowingWater } else { FluidKind::FlowingLava } +} + +/// `FlowingFluid.SpreadContext`: per-spread caches keyed by horizontal offset. +struct SpreadContext { + origin: BlockPos, + states: HashMap, + holes: HashMap, +} +impl SpreadContext { + fn key(&self, pos: BlockPos) -> i16 { + let x = pos.x.wrapping_sub(self.origin.x).wrapping_add(128) & 0xff; + let z = pos.z.wrapping_sub(self.origin.z).wrapping_add(128) & 0xff; + ((x << 8) | z) as i16 + } +} + +impl Sim<'_, L> { + fn fast_lava(&self) -> bool { + self.level.dimension() == Dimension::Nether + } + /// `Fluid.getTickDelay`. + pub(crate) fn fluid_tick_delay(&self, kind: FluidKind) -> i32 { + match kind { + FluidKind::Empty => 0, + FluidKind::Water | FluidKind::FlowingWater => 5, + _ => { + if self.fast_lava() { + 10 + } else { + 30 + } + } + } + } + fn drop_off(&self, kind: FluidKind) -> i32 { + if is_water(kind) || self.fast_lava() { 1 } else { 2 } + } + fn slope_find_distance(&self, kind: FluidKind) -> i32 { + if is_water(kind) || self.fast_lava() { 4 } else { 2 } + } + fn can_convert_to_source(&self, kind: FluidKind) -> bool { + let rules = self.level.game_rules(); + if is_water(kind) { rules.water_source_conversion } else { rules.lava_source_conversion } + } + fn fluid_height(&self, fluid: FluidState, pos: BlockPos) -> f32 { + if fluid.kind() == FluidKind::Empty { + return 0.0; + } + if fluid.kind().same_family(self.fluid_at(above(pos)).kind()) { + 1.0 + } else { + fluid.own_height() + } + } + /// `FluidState.canBeReplacedWith(level, pos, other, direction)`. + fn can_be_replaced_with(&self, fluid: FluidState, pos: BlockPos, other: FluidKind, direction: Direction) -> bool { + match fluid.kind() { + FluidKind::Empty => true, + FluidKind::Water | FluidKind::FlowingWater => direction == Direction::Down && !is_water(other), + _ => self.fluid_height(fluid, pos) >= 0.444_444_45 && is_water(other), + } + } + + // ---- shape occlusion ---- + + fn collision_or_empty(&self, state: BlockStateId) -> (i32, VoxelShape) { + let index = self.b.facts(state).shape; + match self.b.collision_shape(state) { + Some(shape) => (index, shape.clone()), + None => (-1, VoxelShape::empty()), + } + } + /// `FlowingFluid.canPassThroughWall`. + fn can_pass_through_wall(&self, direction: Direction, source: BlockStateId, target: BlockStateId) -> bool { + let (target_index, target_shape) = self.collision_or_empty(target); + let block = VoxelShape::block(); + if target_shape.same_identity(&block) { + return false; + } + let (source_index, source_shape) = self.collision_or_empty(source); + if source_shape.same_identity(&block) { + return false; + } + let empty = VoxelShape::empty(); + if source_shape.same_identity(&empty) && target_shape.same_identity(&empty) { + return true; + } + let cacheable = source_index >= 0 && target_index >= 0; + let key = (source_index, target_index, direction as u8); + if cacheable { + if let Some(result) = self.b.occlusion_cache.lock().ok().and_then(|cache| cache.get(&key).copied()) { + return result; + } + } + let result = !merged_face_occludes(&source_shape, &target_shape, direction); + if cacheable { + if let Ok(mut cache) = self.b.occlusion_cache.lock() { + cache.insert(key, result); + } + } + result + } + + // ---- liquid containers ---- + + /// `LiquidBlockContainer` membership (`canHoldAnyFluid` first clause). + fn is_liquid_container(&self, state: BlockStateId) -> bool { + self.b.implements(state, Interface::LiquidBlockContainer) || self.b.implements(state, Interface::SimpleWaterlogged) + } + /// `LiquidBlockContainer.canPlaceLiquid(null, level, pos, state, fluid)`. + pub(crate) fn can_place_liquid(&self, state: BlockStateId, fluid: FluidKind) -> bool { + let b = self.b; + let data = b.data(state); + if data.is(Class::Kelp) + || data.is(Class::KelpPlant) + || data.is(Class::Seagrass) + || data.is(Class::TallSeagrass) + || data.is(Class::Barrier) + { + return false; + } + if data.is(Class::Slab) && b.table.text(state, b.props.kind) == "double" { + return false; + } + fluid == FluidKind::Water + } + /// `LiquidBlockContainer.placeLiquid`. + pub(crate) fn place_liquid(&mut self, pos: BlockPos, state: BlockStateId, fluid: FluidState) -> bool { + let b = self.b; + if !self.can_place_liquid(state, fluid.kind()) || fluid.kind() != FluidKind::Water || !b.table.has(state, b.props.waterlogged) { + return false; + } + if b.is_waterlogged(state) { + return false; + } + let mut next = b.table.set_bool(state, b.props.waterlogged, true); + let data = b.data(state); + if (data.is(Class::Candle) || data.is(Class::Campfire)) && b.table.bool(state, b.props.lit) { + next = b.table.set_bool(next, b.props.lit, false); + if data.is(Class::Campfire) { + self.emit(super::LevelEvent::Sound { + pos, + sound: "minecraft:block.generic.extinguish_fire".into(), + volume: 1.0, + pitch: 1.0, + }); + } else { + self.emit(super::LevelEvent::Sound { + pos, + sound: "minecraft:block.candle.extinguish".into(), + volume: 1.0, + pitch: 1.0, + }); + } + } + self.set_block_and_update(pos, next); + let delay = self.fluid_tick_delay(fluid.kind()); + self.schedule_fluid_tick(pos, fluid.kind(), delay); + true + } + /// `BucketPickup.pickupBlock`: true when a fluid was taken. + pub(crate) fn pickup_block(&mut self, pos: BlockPos, state: BlockStateId) -> bool { + let b = self.b; + if b.instance_of(state, Class::Liquid) { + if b.table.int(state, b.props.level) == 0 { + self.set_block(pos, b.air(), 11); + return true; + } + return false; + } + if b.implements(state, Interface::SimpleWaterlogged) && b.table.has(state, b.props.waterlogged) { + if b.is_waterlogged(state) { + self.set_block_and_update(pos, b.table.set_bool(state, b.props.waterlogged, false)); + if !self.can_survive(state, pos) { + self.destroy_block(pos, true, 512); + } + return true; + } + return false; + } + if b.is_block(state, b.named.powder_snow) { + self.set_block(pos, b.air(), 11); + return true; + } + false + } + fn can_hold_any_fluid(&self, state: BlockStateId) -> bool { + self.is_liquid_container(state) || self.b.in_set(state, &self.b.tags.washed_away_by_fluids) + } + fn can_hold_specific_fluid(&self, state: BlockStateId, fluid: FluidKind) -> bool { + if self.is_liquid_container(state) { self.can_place_liquid(state, fluid) } else { true } + } + fn can_hold_fluid(&self, state: BlockStateId, fluid: FluidKind) -> bool { + self.can_hold_any_fluid(state) && self.can_hold_specific_fluid(state, fluid) + } + + // ---- FlowingFluid ---- + + fn is_source_of(&self, kind: FluidKind, fluid: FluidState) -> bool { + fluid.kind().same_family(kind) && fluid.is_source() + } + /// `FlowingFluid.getNewLiquid`. + fn new_liquid(&self, kind: FluidKind, pos: BlockPos, state: BlockStateId) -> FluidState { + let b = self.b; + let mut highest = 0; + let mut sources = 0; + for direction in HORIZONTAL { + let neighbour = self.rel_state(pos, direction); + let fluid = b.fluid(neighbour); + if fluid.kind().same_family(kind) && self.can_pass_through_wall(direction, state, neighbour) { + if fluid.is_source() { + sources += 1; + } + highest = highest.max(i32::from(fluid.amount())); + } + } + if sources >= 2 && self.can_convert_to_source(kind) { + let below_state = self.below_state(pos); + if b.is_solid(below_state) || self.is_source_of(kind, b.fluid(below_state)) { + return FluidState::new(source_of(kind), 8, false); + } + } + let above_state = self.above_state(pos); + let above_fluid = b.fluid(above_state); + if above_fluid.kind() != FluidKind::Empty + && above_fluid.kind().same_family(kind) + && self.can_pass_through_wall(Direction::Up, state, above_state) + { + return FluidState::new(flowing_of(kind), 8, true); + } + let amount = highest - self.drop_off(kind); + if amount <= 0 { + FluidState::EMPTY + } else { + FluidState::new(flowing_of(kind), amount as u8, false) + } + } + fn is_water_hole(&self, kind: FluidKind, top: BlockStateId, bottom: BlockStateId) -> bool { + if !self.can_pass_through_wall(Direction::Down, top, bottom) { + return false; + } + if self.b.fluid(bottom).kind().same_family(kind) { + true + } else { + self.can_hold_fluid(bottom, flowing_of(kind)) + } + } + fn can_maybe_pass_through(&self, kind: FluidKind, source: BlockStateId, direction: Direction, test: BlockStateId, test_fluid: FluidState) -> bool { + !self.is_source_of(kind, test_fluid) && self.can_hold_any_fluid(test) && self.can_pass_through_wall(direction, source, test) + } + fn can_pass_through(&self, kind: FluidKind, source: BlockStateId, direction: Direction, test: BlockStateId, test_fluid: FluidState) -> bool { + self.can_maybe_pass_through(kind, source, direction, test, test_fluid) && self.can_hold_specific_fluid(test, flowing_of(kind)) + } + fn context_state(&self, context: &mut SpreadContext, pos: BlockPos) -> BlockStateId { + let key = context.key(pos); + if let Some(state) = context.states.get(&key) { + return *state; + } + let state = self.state(pos); + context.states.insert(key, state); + state + } + fn context_is_hole(&self, kind: FluidKind, context: &mut SpreadContext, pos: BlockPos) -> bool { + let key = context.key(pos); + if let Some(hole) = context.holes.get(&key) { + return *hole; + } + let state = self.context_state(context, pos); + let below_state = self.below_state(pos); + let hole = self.is_water_hole(kind, state, below_state); + context.holes.insert(key, hole); + hole + } + fn slope_distance(&self, kind: FluidKind, pos: BlockPos, pass: i32, from: Direction, state: BlockStateId, context: &mut SpreadContext) -> i32 { + let mut lowest = 1000; + for direction in HORIZONTAL { + if direction == from { + continue; + } + let test_pos = rel(pos, direction); + let test_state = self.context_state(context, test_pos); + let test_fluid = self.b.fluid(test_state); + if self.can_pass_through(kind, state, direction, test_state, test_fluid) { + if self.context_is_hole(kind, context, test_pos) { + return pass; + } + if pass < self.slope_find_distance(kind) { + let distance = self.slope_distance(kind, test_pos, pass + 1, direction.opposite(), test_state, context); + lowest = lowest.min(distance); + } + } + } + lowest + } + /// `FlowingFluid.getSpread` (EnumMap: iteration in Direction order). + fn spread_targets(&self, kind: FluidKind, pos: BlockPos, state: BlockStateId) -> Vec<(Direction, FluidState)> { + let mut lowest = 1000; + let mut result: Vec<(Direction, FluidState)> = Vec::new(); + let mut context: Option = None; + for direction in HORIZONTAL { + let test_pos = rel(pos, direction); + let test_state = self.state(test_pos); + let test_fluid = self.b.fluid(test_state); + if !self.can_maybe_pass_through(kind, state, direction, test_state, test_fluid) { + continue; + } + let new_fluid = self.new_liquid(kind, test_pos, test_state); + if !self.can_hold_specific_fluid(test_state, new_fluid.kind()) { + continue; + } + let context = context.get_or_insert_with(|| SpreadContext { + origin: pos, + states: HashMap::new(), + holes: HashMap::new(), + }); + let distance = if self.context_is_hole(kind, context, test_pos) { + 0 + } else { + self.slope_distance(kind, test_pos, 1, direction.opposite(), test_state, context) + }; + if distance < lowest { + result.clear(); + } + if distance <= lowest { + if self.can_be_replaced_with(test_fluid, test_pos, new_fluid.kind(), direction) { + result.push((direction, new_fluid)); + } + lowest = distance; + } + } + result.sort_by_key(|(direction, _)| *direction as u8); + result + } + fn source_neighbour_count(&self, kind: FluidKind, pos: BlockPos) -> i32 { + HORIZONTAL.into_iter().filter(|d| self.is_source_of(kind, self.fluid_at(rel(pos, *d)))).count() as i32 + } + /// `FlowingFluid.spreadTo` (with LavaFluid's water-to-stone override). + fn spread_to(&mut self, kind: FluidKind, pos: BlockPos, state: BlockStateId, direction: Direction, target: FluidState) { + let b = self.b; + if !is_water(kind) && direction == Direction::Down && b.is_water_fluid(self.fluid_at(pos).kind()) { + if b.instance_of(state, Class::Liquid) { + self.set_block_and_update(pos, b.default_of(b.named.stone)); + } + self.level_event(1501, pos, 0); + return; + } + if self.is_liquid_container(state) { + self.place_liquid(pos, state, target); + } else { + if !b.is_air(state) { + if is_water(kind) { + self.drop_resources(state, pos); + } else { + self.level_event(1501, pos, 0); + } + } + let legacy = b.legacy_block(target); + self.set_block_and_update(pos, legacy); + } + } + fn spread_to_sides(&mut self, kind: FluidKind, pos: BlockPos, fluid: FluidState, state: BlockStateId) { + let mut neighbour = i32::from(fluid.amount()) - self.drop_off(kind); + if fluid.falling() { + neighbour = 7; + } + if neighbour > 0 { + for (direction, new_fluid) in self.spread_targets(kind, pos, state) { + let neighbour_pos = rel(pos, direction); + let neighbour_state = self.state(neighbour_pos); + self.spread_to(kind, neighbour_pos, neighbour_state, direction, new_fluid); + } + } + } + /// `FlowingFluid.spread`. + fn spread(&mut self, kind: FluidKind, pos: BlockPos, state: BlockStateId, fluid: FluidState) { + if fluid.kind() == FluidKind::Empty { + return; + } + let below_pos = below(pos); + let below_state = self.state(below_pos); + let below_fluid = self.b.fluid(below_state); + if self.can_maybe_pass_through(kind, state, Direction::Down, below_state, below_fluid) { + let new_below = self.new_liquid(kind, below_pos, below_state); + if self.can_be_replaced_with(below_fluid, below_pos, new_below.kind(), Direction::Down) + && self.can_hold_specific_fluid(below_state, new_below.kind()) + { + self.spread_to(kind, below_pos, below_state, Direction::Down, new_below); + if self.source_neighbour_count(kind, pos) >= 3 { + self.spread_to_sides(kind, pos, fluid, state); + } + return; + } + } + if fluid.is_source() || !self.is_water_hole(kind, state, below_state) { + self.spread_to_sides(kind, pos, fluid, state); + } + } + /// `FlowingFluid.tick` for the fluid at `pos`. + pub(crate) fn fluid_tick(&mut self, pos: BlockPos) { + let mut state = self.state(pos); + let mut fluid = self.b.fluid(state); + let kind = fluid.kind(); + if kind == FluidKind::Empty { + return; + } + if !fluid.is_source() { + let new_fluid = self.new_liquid(kind, pos, state); + let delay = self.spread_delay(kind, pos, fluid, new_fluid); + if new_fluid.kind() == FluidKind::Empty { + fluid = new_fluid; + state = self.b.air(); + self.set_block_and_update(pos, state); + } else if new_fluid != fluid { + fluid = new_fluid; + state = self.b.legacy_block(fluid); + self.set_block_and_update(pos, state); + self.schedule_fluid_tick(pos, fluid.kind(), delay); + } + } + self.spread(kind, pos, state, fluid); + } + fn spread_delay(&mut self, kind: FluidKind, pos: BlockPos, old: FluidState, new: FluidState) -> i32 { + let delay = self.fluid_tick_delay(kind); + if is_water(kind) { + return delay; + } + if old.kind() != FluidKind::Empty + && new.kind() != FluidKind::Empty + && !old.falling() + && !new.falling() + && self.fluid_height(new, pos) > self.fluid_height(old, pos) + && self.random().next_int_bound(4).unwrap_or(0) != 0 + { + delay * 4 + } else { + delay + } + } + + // ---- LiquidBlock ---- + + /// `LiquidBlock.shouldSpreadLiquid`, including lava's conversions. + pub(crate) fn should_spread_liquid(&mut self, pos: BlockPos, state: BlockStateId) -> bool { + let b = self.b; + if !b.is_lava_fluid(b.fluid(state).kind()) { + return true; + } + let over_soul_soil = b.is_block(self.below_state(pos), b.named.soul_soil); + for direction in POSSIBLE_FLOW_DIRECTIONS { + let neighbour = rel(pos, direction.opposite()); + if b.is_water_fluid(self.fluid_at(neighbour).kind()) { + let block = if self.fluid_at(pos).is_source() { b.named.obsidian } else { b.named.cobblestone }; + self.set_block_and_update(pos, b.default_of(block)); + self.level_event(1501, pos, 0); + return false; + } + if over_soul_soil && b.is_block(self.state(neighbour), b.named.blue_ice) { + self.set_block_and_update(pos, b.default_of(b.named.basalt)); + self.level_event(1501, pos, 0); + return false; + } + } + true + } + /// `LiquidBlock.onPlace` / `neighborChanged`. + pub(crate) fn liquid_block_changed(&mut self, pos: BlockPos, state: BlockStateId) { + if self.should_spread_liquid(pos, state) { + let kind = self.b.fluid(state).kind(); + let delay = self.fluid_tick_delay(kind); + self.schedule_fluid_tick(pos, kind, delay); + } + if self.should_bubble_column_occupy(state) { + let below_state = self.below_state(pos); + let block = self.b.block(state); + self.try_schedule_bubble_column(pos, below_state, block); + } + } + + /// `LavaFluid.randomTick`. + pub(crate) fn lava_random_tick(&mut self, pos: BlockPos) { + if !self.level.can_spread_fire_around(pos) { + return; + } + let passes = self.random().next_int_bound(3).unwrap_or(0); + if passes > 0 { + let mut test = pos; + for _ in 0..passes { + let dx = self.random().next_int_bound(3).unwrap_or(0) - 1; + let dz = self.random().next_int_bound(3).unwrap_or(0) - 1; + test = test.offset(dx, 1, dz); + if !self.level.is_loaded(test) { + return; + } + let state = self.state(test); + if self.b.is_air(state) { + if Direction::ALL.into_iter().any(|d| self.lava_flammable(rel(test, d))) { + let fire = self.fire_state_for(test); + self.set_block_and_update(test, fire); + return; + } + } else if self.b.tag("minecraft:blocks_lava_fire_spread").is_some_and(|tag| self.b.in_set(state, tag)) { + return; + } + } + } else { + for _ in 0..3 { + let dx = self.random().next_int_bound(3).unwrap_or(0) - 1; + let dz = self.random().next_int_bound(3).unwrap_or(0) - 1; + let test = pos.offset(dx, 0, dz); + if !self.level.is_loaded(test) { + return; + } + if self.is_empty_block(above(test)) && self.lava_flammable(test) { + let fire = self.fire_state_for(test); + self.set_block_and_update(above(test), fire); + } + } + } + } + fn lava_flammable(&self, pos: BlockPos) -> bool { + if self.is_inside_build_height(pos.y) && !self.level.is_loaded(pos) { + return false; + } + self.b.has_flag(self.state(pos), super::data::state_flags::IGNITED_BY_LAVA) + } +} + +/// `Shapes.mergedFaceOccludes(shape, occluder, direction)`. +pub(crate) fn merged_face_occludes(shape: &VoxelShape, occluder: &VoxelShape, direction: Direction) -> bool { + let block = VoxelShape::block(); + if shape.same_identity(&block) || occluder.same_identity(&block) { + return true; + } + let positive = matches!(direction, Direction::Up | Direction::South | Direction::East); + let axis = match direction { + Direction::West | Direction::East => Axis::X, + Direction::Down | Direction::Up => Axis::Y, + _ => Axis::Z, + }; + let (first, second) = if positive { (shape, occluder) } else { (occluder, shape) }; + let max_face = match axis { + Axis::X => Direction::East, + Axis::Y => Direction::Up, + Axis::Z => Direction::South, + }; + let empty = VoxelShape::empty(); + // SliceShape(first, axis, last layer) / SliceShape(second, axis, 0): the face + // shapes sample the same boundary layers when the shapes touch the face. + let first_slice = if !first.is_empty() && (first.max(axis) - 1.0).abs() <= 1.0e-7 { + first.face_shape(max_face).unwrap_or_else(|_| empty.clone()) + } else { + empty.clone() + }; + let second_slice = if !second.is_empty() && second.min(axis).abs() <= 1.0e-7 { + second.face_shape(max_face.opposite()).unwrap_or_else(|_| empty.clone()) + } else { + empty.clone() + }; + let union = match first_slice.join(&second_slice, ShapeOp::OR) { + Ok(shape) => shape, + Err(_) => return false, + }; + !block.join_is_not_empty(&union, ShapeOp::ONLY_FIRST).unwrap_or(true) +} diff --git a/crates/horizon-world/src/level/hooks.rs b/crates/horizon-world/src/level/hooks.rs new file mode 100644 index 000000000..5aaa21836 --- /dev/null +++ b/crates/horizon-world/src/level/hooks.rs @@ -0,0 +1,411 @@ +//! `neighborChanged`, `onPlace`, `affectNeighborsAfterRemoval` and +//! `updateIndirectNeighbourShapes` for the overriding vanilla classes. +use super::{ + LevelAccess, Sim, + classes::Class, + states::BlockId, + update::{HORIZONTAL, below, rel}, +}; +use crate::registry::BlockStateId; +use horizon_core::{geometry::Direction, position::BlockPos, random::RandomSource}; + +impl Sim<'_, L> { + /// `BlockState.handleNeighborChanged`. + pub fn neighbor_changed(&mut self, state: BlockStateId, pos: BlockPos, changed: BlockId, moved: bool) { + let b = self.b; + let block = b.block(state); + let chain = b.data(state).chain.clone(); + for class in chain { + match class { + Class::AbstractSkull => self.skull_neighbor_changed(pos, state), + Class::BaseRail => self.rail_neighbor_changed(pos, state, changed, moved), + Class::Bell => self.bell_neighbor_changed(pos, state), + Class::BigDripleaf => { + if self.has_neighbor_signal(pos) { + self.big_dripleaf_reset_tilt(pos, state); + } + } + Class::CopperBulb => self.copper_bulb_check(pos, state), + Class::Crafter => self.crafter_neighbor_changed(pos, state), + Class::Diode => self.diode_neighbor_changed(pos, state), + Class::Dispenser => self.dispenser_neighbor_changed(pos, state), + Class::Door => self.door_neighbor_changed(pos, state, changed), + Class::FenceGate => self.gate_neighbor_changed(pos, state), + Class::FrostedIce => { + if b.block_data(changed).is(Class::FrostedIce) && self.frosted_ice_fewer_neighbours_than(pos, 2) { + self.frosted_ice_melt(pos, state); + } + } + Class::Hopper => self.hopper_check_powered(pos, state), + Class::Liquid => self.liquid_block_changed(pos, state), + Class::Note => self.note_neighbor_changed(pos, state), + Class::RedstoneLamp => self.lamp_neighbor_changed(pos, state), + Class::RedstoneTorch => self.torch_neighbor_changed(pos, state), + Class::RedstoneWire => { + if self.can_survive(state, pos) { + self.wire_update_power(pos, state); + } else { + self.drop_resources(state, pos); + self.remove_block(pos, false); + } + } + Class::Sponge => self.sponge_try_absorb(pos), + Class::Tnt => self.tnt_check(pos), + Class::TrapDoor => self.trapdoor_neighbor_changed(pos, state), + _ => continue, + } + let _ = block; + return; + } + } + + /// `BlockState.onPlace`. + pub fn on_place(&mut self, state: BlockStateId, pos: BlockPos, old: BlockStateId, moved: bool) { + let b = self.b; + let block = b.block(state); + let same = b.block(old) == block; + let chain = b.data(state).chain.clone(); + for class in chain { + match class { + Class::Fire => { + self.base_fire_on_place(pos, state, same); + let delay = 30 + self.random().next_int_bound(10).unwrap_or(0); + self.schedule_tick(pos, block, delay); + } + Class::BaseFire => self.base_fire_on_place(pos, state, same), + Class::DetectorRail | Class::BaseRail => { + if !same { + self.rail_update_state(pos, state, moved); + } + } + Class::Brushable => self.schedule_tick(pos, block, 2), + Class::Composter => { + if b.table.int(state, b.props.level) == 7 { + self.schedule_tick(pos, block, 20); + } + } + Class::CopperBulb => { + if !same { + self.copper_bulb_check(pos, state); + } + } + Class::CoralFan | Class::CoralPlant | Class::CoralWallFan => self.coral_try_schedule_die_tick(state, pos), + Class::Diode => self.diode_update_neighbors_in_front(pos, state), + Class::FallingBlock => { + let delay = if b.data(state).is(Class::DragonEgg) { 5 } else { 2 }; + self.schedule_tick(pos, block, delay); + } + Class::Frogspawn => { + let delay = self.random().next_int_between(3600, 12000).unwrap_or(3600); + self.schedule_tick(pos, block, delay); + } + Class::FrostedIce => { + let delay = self.random().next_int_between_inclusive(60, 120).unwrap_or(60); + self.schedule_tick(pos, block, delay); + } + Class::Hopper => { + if !same { + self.hopper_check_powered(pos, state); + } + } + Class::LightningRod => { + if !same && b.table.bool(state, b.props.powered) && !self.ticks.has_block_tick(pos, block) { + self.schedule_tick(pos, block, 8); + } + } + Class::Liquid => self.liquid_block_changed(pos, state), + Class::Observer => { + if !same && b.table.bool(state, b.props.powered) && !self.ticks.has_block_tick(pos, block) { + let next = b.table.set_bool(state, b.props.powered, false); + self.set_block(pos, next, 18); + self.observer_update_in_front(pos, next); + } + } + Class::RedstoneTorch => self.torch_notify_neighbors(pos, state), + Class::RedstoneWire => { + if !same { + self.wire_update_power(pos, state); + for direction in [Direction::Up, Direction::Down] { + self.update_neighbors_at(rel(pos, direction), block); + } + self.wire_update_neighbors_of_neighboring_wires(pos); + } + } + Class::Scaffolding => self.schedule_tick(pos, block, 1), + Class::SculkSensor => { + if !same && b.table.int(state, b.props.power) > 0 && !self.ticks.has_block_tick(pos, block) { + self.set_block(pos, b.table.set_int(state, b.props.power, 0), 18); + } + } + Class::Sponge => { + if !same { + self.sponge_try_absorb(pos); + } + } + Class::WetSponge => { + if self.level.dimension() == super::Dimension::Nether { + self.set_block_and_update(pos, b.default_of(b.named.sponge)); + self.level_event(2009, pos, 0); + let pitch = (1.0 + self.random().next_float() * 0.2) * 0.7; + self.emit(super::LevelEvent::Sound { + pos, + sound: "minecraft:block.wet_sponge.dries".into(), + volume: 1.0, + pitch, + }); + } + } + Class::Target => { + if !same && b.table.int(state, b.props.power) > 0 && !self.ticks.has_block_tick(pos, block) { + self.set_block(pos, b.table.set_int(state, b.props.power, 0), 18); + } + } + Class::Tnt => { + if !same { + self.tnt_check(pos); + } + } + Class::TripWire => { + if !same { + self.tripwire_update_source(pos, state); + } + } + Class::TurtleEgg => { + if b.in_set(self.below_state(pos), &b.tags.sand) { + self.level_event(2012, pos, 15); + } + } + _ => continue, + } + return; + } + } + + /// `BlockState.affectNeighborsAfterRemoval`. + pub fn affect_neighbors_after_removal(&mut self, state: BlockStateId, pos: BlockPos, moved: bool) { + let b = self.b; + let block = b.block(state); + let chain = b.data(state).chain.clone(); + for class in chain { + match class { + Class::AbstractFurnace + | Class::Barrel + | Class::BrewingStand + | Class::Chest + | Class::ChiseledBookShelf + | Class::Crafter + | Class::CreakingHeart + | Class::DecoratedPot + | Class::Dispenser + | Class::Hopper + | Class::Jukebox + | Class::ShulkerBox + | Class::CopperGolemStatue => self.update_neighbour_for_output_signal(pos, block), + Class::Shelf => self.update_neighbour_for_output_signal(pos, block), + Class::BasePressurePlate => { + if !moved && self.plate_signal_for_state(state) > 0 { + self.plate_update_neighbours(pos, block); + } + } + Class::BaseRail => { + if !moved { + if self.rail_shape(state).starts_with("ascending") { + self.update_neighbors_at(super::update::above(pos), block); + } + if !b.data(state).is(Class::Rail) { + self.update_neighbors_at(pos, block); + self.update_neighbors_at(below(pos), block); + } + } + } + Class::Button | Class::Lever => { + if !moved && b.table.bool(state, b.props.powered) { + self.attached_update_neighbours(pos, state); + } + } + Class::LightningRod => { + if b.table.bool(state, b.props.powered) { + let facing = b.facing(state); + self.update_neighbors_at(rel(pos, facing.opposite()), block); + } + } + Class::Lectern => { + if b.table.bool(state, b.props.powered) { + self.update_neighbors_at(below(pos), block); + } + } + Class::Diode => { + if !moved { + self.diode_update_neighbors_in_front(pos, state); + } + } + Class::Observer => { + if b.table.bool(state, b.props.powered) && self.ticks.has_block_tick(pos, block) { + let off = b.table.set_bool(state, b.props.powered, false); + self.observer_update_in_front(pos, off); + } + } + Class::RedstoneTorch => { + if !moved { + self.torch_notify_neighbors(pos, state); + } + } + Class::RedstoneWire => { + if !moved { + for direction in Direction::ALL { + self.update_neighbors_at(rel(pos, direction), block); + } + self.wire_update_power(pos, state); + self.wire_update_neighbors_of_neighboring_wires(pos); + } + } + Class::SculkSensor => { + if b.table.text(state, b.table_phase_key()) == "active" { + self.update_neighbors_at(pos, block); + self.update_neighbors_at(below(pos), block); + } + } + Class::TripWire => { + if !moved { + let powered = b.table.set_bool(state, b.props.powered, true); + self.tripwire_update_source(pos, powered); + } + } + Class::TripWireHook => { + if !moved { + self.tripwire_hook_removed(pos, state); + } + } + _ => continue, + } + return; + } + } + + /// `BlockState.updateIndirectNeighbourShapes` (only redstone wire overrides it). + pub fn update_indirect_neighbour_shapes(&mut self, state: BlockStateId, pos: BlockPos, flags: i32, limit: i32) { + if self.b.is_block(state, self.b.named.redstone_wire) { + self.wire_update_indirect(state, pos, flags, limit); + } + } + + // ---- misc helpers ---- + + /// `BaseFireBlock.onPlace` (portal ignition is not modelled). + fn base_fire_on_place(&mut self, pos: BlockPos, state: BlockStateId, same: bool) { + if !same && !self.can_survive(state, pos) { + self.remove_block(pos, false); + } + } + /// `SpongeBlock.tryAbsorbWater`. + pub(crate) fn sponge_try_absorb(&mut self, start: BlockPos) { + if self.sponge_remove_water(start) { + let b = self.b; + self.set_block(start, b.default_of(b.named.wet_sponge), 2); + self.emit(super::LevelEvent::Sound { + pos: start, + sound: "minecraft:block.sponge.absorb".into(), + volume: 1.0, + pitch: 1.0, + }); + } + } + fn sponge_remove_water(&mut self, start: BlockPos) -> bool { + use std::collections::{HashSet, VecDeque}; + let b = self.b; + let mut queue = VecDeque::from([(start, 0)]); + let mut visited = HashSet::new(); + let mut count = 0; + while let Some((pos, depth)) = queue.pop_front() { + if !visited.insert(pos) { + continue; + } + let accept = if pos == start { + true + } else { + let state = self.state(pos); + if !b.is_water_fluid(self.fluid_at(pos).kind()) { + false + } else if self.pickup_block(pos, state) { + true + } else { + if b.instance_of(state, Class::Liquid) { + self.set_block_and_update(pos, b.air()); + } else { + let n = b.named; + let block = b.block(state); + if block != n.kelp && block != n.kelp_plant && block != n.seagrass && block != n.tall_seagrass { + continue; + } + self.drop_resources(state, pos); + self.set_block_and_update(pos, b.air()); + } + true + } + }; + if !accept { + continue; + } + count += 1; + if count >= 65 { + return count > 1; + } + if depth < 6 { + for direction in Direction::ALL { + queue.push_back((rel(pos, direction), depth + 1)); + } + } + } + count > 1 + } + fn frosted_ice_fewer_neighbours_than(&self, pos: BlockPos, limit: i32) -> bool { + let mut count = 0; + for direction in Direction::ALL { + if self.b.data(self.rel_state(pos, direction)).is(Class::FrostedIce) { + count += 1; + if count >= limit { + return false; + } + } + } + true + } + /// `FrostedIceBlock.melt` → `IceBlock.melt`. + pub(crate) fn frosted_ice_melt(&mut self, pos: BlockPos, _state: BlockStateId) { + self.ice_melt(pos); + } + /// `IceBlock.melt`. + pub(crate) fn ice_melt(&mut self, pos: BlockPos) { + let b = self.b; + if self.level.dimension() == super::Dimension::Nether { + self.remove_block(pos, false); + } else { + let water = b.default_of(b.named.water); + self.set_block_and_update(pos, water); + self.neighbor_changed_at(pos, b.named.water); + } + } + fn big_dripleaf_reset_tilt(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + if b.table.text(state, b.props.tilt) != "none" { + let next = b.table.set_text(state, b.props.tilt, "none"); + self.set_block(pos, next, 2); + self.emit(super::LevelEvent::Sound { + pos, + sound: "minecraft:block.big_dripleaf.tilt_up".into(), + volume: 1.0, + pitch: 1.0, + }); + self.ticks.blocks.clear_area(horizon_core::ticks::TickArea::new(pos, pos)); + } + } + pub(crate) fn horizontal_neighbours(pos: BlockPos) -> [BlockPos; 4] { + HORIZONTAL.map(|d| rel(pos, d)) + } +} + +impl super::Behaviours { + pub(crate) fn table_phase_key(&self) -> super::states::PropKey { + self.props.sculk_sensor_phase + } +} diff --git a/crates/horizon-world/src/level/mod.rs b/crates/horizon-world/src/level/mod.rs index 6ee6a8e09..eef27c95f 100644 --- a/crates/horizon-world/src/level/mod.rs +++ b/crates/horizon-world/src/level/mod.rs @@ -233,6 +233,17 @@ pub trait LevelAccess { fn is_unobstructed(&self, _pos: BlockPos, _state: BlockStateId) -> bool { true } + /// Comparator input from a block entity (`getAnalogOutputSignal` of + /// containers, jukeboxes, lecterns, ...). State-only sources (cake, + /// composter, cauldrons, beehives, ...) are evaluated by the library. + fn block_entity_analog_signal(&self, _pos: BlockPos, _state: BlockStateId, _direction: Direction) -> i32 { + 0 + } + /// Weak/strong signal of a block-entity-driven source (trapped chest + /// openers); other sources are evaluated by the library. + fn block_entity_signal(&self, _pos: BlockPos, _state: BlockStateId, _direction: Direction) -> i32 { + 0 + } /// Count of entities intersecting `area` that trigger pressure plates or /// tripwires under `query`. fn count_entities(&self, _area: Aabb, _query: EntityQuery) -> usize { @@ -348,4 +359,17 @@ pub(crate) struct Sim<'a, L: LevelAccess + ?Sized> { pub b: &'a Behaviours, pub level: &'a mut L, pub ticks: &'a mut Ticks, + /// `RedstoneWireBlock.shouldSignal` is false while a wire samples its + /// neighbours (`getBlockSignal`). + pub wire_signal_off: std::cell::Cell, +} +impl Behaviours { + pub(crate) fn sim<'a, L: LevelAccess + ?Sized>(&'a self, level: &'a mut L, ticks: &'a mut Ticks) -> Sim<'a, L> { + Sim { + b: self, + level, + ticks, + wire_signal_off: std::cell::Cell::new(false), + } + } } diff --git a/crates/horizon-world/src/level/redstone.rs b/crates/horizon-world/src/level/redstone.rs new file mode 100644 index 000000000..9df44d4c6 --- /dev/null +++ b/crates/horizon-world/src/level/redstone.rs @@ -0,0 +1,998 @@ +//! Redstone: `SignalGetter`, redstone wire (default evaluator), torches, +//! diodes (repeaters, comparators), observers, lamps and the power-driven +//! responses of doors, trapdoors, gates and other consumers. +use super::{ + LevelAccess, LevelEvent, Sim, + classes::Class, + data::state_flags, + query::{clockwise, counter_clockwise}, + states::BlockId, + update::{HORIZONTAL, above, below, rel}, +}; +use crate::registry::BlockStateId; +use horizon_core::{geometry::Direction, position::BlockPos, random::RandomSource, ticks::TickPriority}; + +const SIGNAL_ORDER: [Direction; 6] = [ + Direction::Down, + Direction::Up, + Direction::North, + Direction::South, + Direction::West, + Direction::East, +]; + +impl Sim<'_, L> { + fn nibble(word: u32, direction: Direction) -> i32 { + ((word >> (4 * direction as u32)) & 15) as i32 + } + pub(crate) fn is_signal_source(&self, state: BlockStateId) -> bool { + if self.b.is_block(state, self.b.named.redstone_wire) { + return !self.wire_signal_off.get(); + } + self.b.has_flag(state, state_flags::SIGNAL_SOURCE) + } + /// `BlockState.getSignal(level, pos, direction)`. + pub(crate) fn state_signal(&self, state: BlockStateId, pos: BlockPos, direction: Direction) -> i32 { + let b = self.b; + if !b.has_flag(state, state_flags::SIGNAL_SOURCE) { + return 0; + } + let data = b.data(state); + match data.class { + Class::RedstoneWire => self.wire_signal(state, pos, direction), + Class::Comparator => { + if b.facing(state) == direction && b.table.bool(state, b.props.powered) { + self.comparator_output(pos) + } else { + 0 + } + } + Class::TrappedChest => self.level.block_entity_signal(pos, state, direction), + _ => Self::nibble(b.facts(state).weak, direction), + } + } + /// `BlockState.getDirectSignal(level, pos, direction)`. + pub(crate) fn state_direct_signal(&self, state: BlockStateId, pos: BlockPos, direction: Direction) -> i32 { + let b = self.b; + if !b.has_flag(state, state_flags::SIGNAL_SOURCE) { + return 0; + } + match b.data(state).class { + Class::RedstoneWire => { + if self.wire_signal_off.get() { + 0 + } else { + self.wire_signal(state, pos, direction) + } + } + Class::Comparator => self.state_signal(state, pos, direction), + Class::TrappedChest => { + if direction == Direction::Up { + self.level.block_entity_signal(pos, state, direction) + } else { + 0 + } + } + _ => Self::nibble(b.facts(state).strong, direction), + } + } + pub(crate) fn comparator_output(&self, pos: BlockPos) -> i32 { + self.ticks.comparator_outputs.get(&pos).copied().unwrap_or(0) + } + fn wire_signal(&self, state: BlockStateId, pos: BlockPos, direction: Direction) -> i32 { + if self.wire_signal_off.get() || direction == Direction::Down { + return 0; + } + let power = self.b.table.int(state, self.b.props.power); + if power == 0 { + return 0; + } + if direction != Direction::Up { + let connected = self.wire_connection_state(state, pos); + if self.b.table.text(connected, self.direction_prop(direction.opposite())) == "none" { + return 0; + } + } + power + } + /// `SignalGetter.getDirectSignal(pos, direction)`. + pub fn direct_signal(&self, pos: BlockPos, direction: Direction) -> i32 { + self.state_direct_signal(self.state(pos), pos, direction) + } + /// `SignalGetter.getDirectSignalTo`. + pub fn direct_signal_to(&self, pos: BlockPos) -> i32 { + let mut result = 0; + for direction in SIGNAL_ORDER { + result = result.max(self.direct_signal(rel(pos, direction), direction)); + if result >= 15 { + return result; + } + } + result + } + /// `SignalGetter.getSignal(pos, direction)`. + pub fn signal(&self, pos: BlockPos, direction: Direction) -> i32 { + let state = self.state(pos); + let signal = self.state_signal(state, pos, direction); + if self.is_redstone_conductor(state, pos) { + signal.max(self.direct_signal_to(pos)) + } else { + signal + } + } + pub fn has_signal(&self, pos: BlockPos, direction: Direction) -> bool { + self.signal(pos, direction) > 0 + } + /// `SignalGetter.hasNeighborSignal`. + pub fn has_neighbor_signal(&self, pos: BlockPos) -> bool { + SIGNAL_ORDER.into_iter().any(|direction| self.signal(rel(pos, direction), direction) > 0) + } + /// `SignalGetter.getBestNeighborSignal`. + pub fn best_neighbor_signal(&self, pos: BlockPos) -> i32 { + let mut best = 0; + for direction in SIGNAL_ORDER { + let signal = self.signal(rel(pos, direction), direction); + if signal >= 15 { + return 15; + } + best = best.max(signal); + } + best + } + /// `SignalGetter.getControlInputSignal`. + fn control_input_signal(&self, pos: BlockPos, direction: Direction, only_diodes: bool) -> i32 { + let b = self.b; + let state = self.state(pos); + if only_diodes { + if b.instance_of(state, Class::Diode) { self.direct_signal(pos, direction) } else { 0 } + } else if b.is_block(state, b.named.redstone_block) { + 15 + } else if b.is_block(state, b.named.redstone_wire) { + b.table.int(state, b.props.power) + } else if self.is_signal_source(state) { + self.direct_signal(pos, direction) + } else { + 0 + } + } + + // ---- redstone wire ---- + + fn should_wire_connect_to(&self, state: BlockStateId, direction: Option) -> bool { + let b = self.b; + match b.data(state).class { + Class::RedstoneWire => true, + Class::Observer => direction == Some(b.facing(state)), + Class::Repeater => { + let facing = b.facing(state); + direction == Some(facing) || direction == Some(facing.opposite()) + } + _ => self.is_signal_source(state) && direction.is_some(), + } + } + fn wire_can_survive_on(&self, state: BlockStateId) -> bool { + self.b.is_face_sturdy(state, Direction::Up) || self.b.is_block(state, self.b.named.hopper) + } + fn wire_connecting_side(&self, pos: BlockPos, direction: Direction, can_connect_up: bool) -> &'static str { + let b = self.b; + let relative_pos = rel(pos, direction); + let relative = self.state(relative_pos); + if can_connect_up { + let placeable_above = b.instance_of(relative, Class::TrapDoor) || self.wire_can_survive_on(relative); + if placeable_above && self.should_wire_connect_to(self.state(above(relative_pos)), None) { + return if b.is_face_sturdy(relative, direction.opposite()) { "up" } else { "side" }; + } + } + if !self.should_wire_connect_to(relative, Some(direction)) + && (self.is_redstone_conductor(relative, relative_pos) || !self.should_wire_connect_to(self.state(below(relative_pos)), None)) + { + "none" + } else { + "side" + } + } + fn wire_can_connect_up(&self, pos: BlockPos) -> bool { + !self.is_redstone_conductor(self.above_state(pos), pos) + } + fn wire_connected(&self, state: BlockStateId, direction: Direction) -> bool { + self.b.table.text(state, self.direction_prop(direction)) != "none" + } + fn wire_is_cross(&self, state: BlockStateId) -> bool { + HORIZONTAL.into_iter().all(|d| self.wire_connected(state, d)) + } + fn wire_is_dot(&self, state: BlockStateId) -> bool { + !HORIZONTAL.into_iter().any(|d| self.wire_connected(state, d)) + } + pub(crate) fn wire_cross_state(&self, power: i32) -> BlockStateId { + let b = self.b; + let mut state = b.default_of(b.named.redstone_wire); + for direction in HORIZONTAL { + state = b.table.set_text(state, self.direction_prop(direction), "side"); + } + b.table.set_int(state, b.props.power, power) + } + /// `RedstoneWireBlock.getConnectionState`. + pub(crate) fn wire_connection_state(&self, state: BlockStateId, pos: BlockPos) -> BlockStateId { + let b = self.b; + let table = &b.table; + let was_dot = self.wire_is_dot(state); + let mut result = table.set_int(b.default_of(b.named.redstone_wire), b.props.power, table.int(state, b.props.power)); + let can_up = self.wire_can_connect_up(pos); + for direction in HORIZONTAL { + if !self.wire_connected(result, direction) { + let side = self.wire_connecting_side(pos, direction, can_up); + result = table.set_text(result, self.direction_prop(direction), side); + } + } + if was_dot && self.wire_is_dot(result) { + return result; + } + let north = self.wire_connected(result, Direction::North); + let south = self.wire_connected(result, Direction::South); + let east = self.wire_connected(result, Direction::East); + let west = self.wire_connected(result, Direction::West); + let ns_empty = !north && !south; + let ew_empty = !east && !west; + if !west && ns_empty { + result = table.set_text(result, b.props.west, "side"); + } + if !east && ns_empty { + result = table.set_text(result, b.props.east, "side"); + } + if !north && ew_empty { + result = table.set_text(result, b.props.north, "side"); + } + if !south && ew_empty { + result = table.set_text(result, b.props.south, "side"); + } + result + } + pub(crate) fn redstone_wire_update_shape( + &self, + state: BlockStateId, + pos: BlockPos, + direction: Direction, + _npos: BlockPos, + neighbour: BlockStateId, + ) -> BlockStateId { + let b = self.b; + match direction { + Direction::Down => { + if self.wire_can_survive_on(neighbour) { + state + } else { + b.air() + } + } + Direction::Up => self.wire_connection_state(state, pos), + _ => { + let side = self.wire_connecting_side(pos, direction, self.wire_can_connect_up(pos)); + let key = self.direction_prop(direction); + if (side != "none") == self.wire_connected(state, direction) && !self.wire_is_cross(state) { + b.table.set_text(state, key, side) + } else { + let power = b.table.int(state, b.props.power); + let cross = b.table.set_text(self.wire_cross_state(power), key, side); + self.wire_connection_state(cross, pos) + } + } + } + } + /// `RedstoneWireBlock.updateIndirectNeighbourShapes`. + pub(crate) fn wire_update_indirect(&mut self, state: BlockStateId, pos: BlockPos, flags: i32, limit: i32) { + let b = self.b; + let wire = b.named.redstone_wire; + for direction in HORIZONTAL { + if b.table.text(state, self.direction_prop(direction)) != "none" && !b.is_block(self.rel_state(pos, direction), wire) { + let down = below(rel(pos, direction)); + if b.is_block(self.state(down), wire) { + let neighbour = rel(down, direction.opposite()); + let neighbour_state = self.state(neighbour); + self.neighbor_shape_changed(direction.opposite(), down, neighbour, neighbour_state, flags, limit); + } + let up = above(rel(pos, direction)); + if b.is_block(self.state(up), wire) { + let neighbour = rel(up, direction.opposite()); + let neighbour_state = self.state(neighbour); + self.neighbor_shape_changed(direction.opposite(), up, neighbour, neighbour_state, flags, limit); + } + } + } + } + fn wire_block_signal(&self, pos: BlockPos) -> i32 { + self.wire_signal_off.set(true); + let signal = self.best_neighbor_signal(pos); + self.wire_signal_off.set(false); + signal + } + fn wire_power_of(&self, state: BlockStateId) -> i32 { + if self.b.is_block(state, self.b.named.redstone_wire) { + self.b.table.int(state, self.b.props.power) + } else { + 0 + } + } + fn wire_incoming_signal(&self, pos: BlockPos) -> i32 { + let mut signal = 0; + for direction in HORIZONTAL { + let neighbour_pos = rel(pos, direction); + let neighbour = self.state(neighbour_pos); + signal = signal.max(self.wire_power_of(neighbour)); + let above_pos = above(pos); + if self.is_redstone_conductor(neighbour, neighbour_pos) && !self.is_redstone_conductor(self.state(above_pos), above_pos) { + signal = signal.max(self.wire_power_of(self.state(above(neighbour_pos)))); + } else if !self.is_redstone_conductor(neighbour, neighbour_pos) { + signal = signal.max(self.wire_power_of(self.state(below(neighbour_pos)))); + } + } + (signal - 1).max(0) + } + /// `DefaultRedstoneWireEvaluator.updatePowerStrength`. + pub(crate) fn wire_update_power(&mut self, pos: BlockPos, state: BlockStateId) { + let block_signal = self.wire_block_signal(pos); + let target = if block_signal == 15 { + 15 + } else { + block_signal.max(self.wire_incoming_signal(pos)) + }; + if self.b.table.int(state, self.b.props.power) != target { + if self.state(pos) == state { + let next = self.b.table.set_int(state, self.b.props.power, target); + self.set_block(pos, next, 2); + } + // Vanilla iterates a HashSet of the position and its six + // neighbours; BlockPos hash order is reproduced below. + let wire = self.b.named.redstone_wire; + let mut targets: Vec = std::iter::once(pos).chain(Direction::ALL.map(|d| rel(pos, d))).collect(); + java_hash_set_order(&mut targets); + for target_pos in targets { + self.update_neighbors_at(target_pos, wire); + } + } + } + fn wire_check_corner(&mut self, pos: BlockPos) { + let wire = self.b.named.redstone_wire; + if self.b.is_block(self.state(pos), wire) { + self.update_neighbors_at(pos, wire); + for direction in Direction::ALL { + self.update_neighbors_at(rel(pos, direction), wire); + } + } + } + pub(crate) fn wire_update_neighbors_of_neighboring_wires(&mut self, pos: BlockPos) { + for direction in HORIZONTAL { + self.wire_check_corner(rel(pos, direction)); + } + for direction in HORIZONTAL { + let target = rel(pos, direction); + if self.is_redstone_conductor(self.state(target), target) { + self.wire_check_corner(above(target)); + } else { + self.wire_check_corner(below(target)); + } + } + } + + // ---- diodes ---- + + pub(crate) fn diode_delay(&self, state: BlockStateId) -> i32 { + if self.b.instance_of(state, Class::Repeater) { + self.b.table.int(state, self.b.props.delay) * 2 + } else { + 2 + } + } + pub(crate) fn diode_is_locked(&self, pos: BlockPos, state: BlockStateId) -> bool { + self.b.instance_of(state, Class::Repeater) && self.diode_alternate_signal(pos, state) > 0 + } + fn diode_alternate_signal(&self, pos: BlockPos, state: BlockStateId) -> i32 { + let facing = self.b.facing(state); + let only_diodes = self.b.instance_of(state, Class::Repeater); + let cw = clockwise(facing); + let ccw = counter_clockwise(facing); + self.control_input_signal(rel(pos, cw), cw, only_diodes) + .max(self.control_input_signal(rel(pos, ccw), ccw, only_diodes)) + } + fn diode_input_signal(&self, pos: BlockPos, state: BlockStateId) -> i32 { + let b = self.b; + let facing = b.facing(state); + let target = rel(pos, facing); + let input = self.signal(target, facing); + let mut result = if input >= 15 { + input + } else { + let target_state = self.state(target); + input.max(self.wire_power_of(target_state)) + }; + if b.instance_of(state, Class::Comparator) { + let target_state = self.state(target); + if b.has_flag(target_state, state_flags::ANALOG_OUTPUT) { + result = self.analog_output(target_state, target, facing.opposite()); + } else if result < 15 && self.is_redstone_conductor(target_state, target) { + let further = rel(target, facing); + let further_state = self.state(further); + if b.has_flag(further_state, state_flags::ANALOG_OUTPUT) { + result = self.analog_output(further_state, further, facing.opposite()); + } + } + } + result + } + fn diode_should_turn_on(&self, pos: BlockPos, state: BlockStateId) -> bool { + if self.b.instance_of(state, Class::Comparator) { + let input = self.diode_input_signal(pos, state); + if input == 0 { + return false; + } + let side = self.diode_alternate_signal(pos, state); + input > side || (input == side && self.b.table.text(state, self.b.props.mode) == "compare") + } else { + self.diode_input_signal(pos, state) > 0 + } + } + fn diode_should_prioritize(&self, pos: BlockPos, state: BlockStateId) -> bool { + let direction = self.b.facing(state).opposite(); + let opposite = self.rel_state(pos, direction); + self.b.instance_of(opposite, Class::Diode) && self.b.facing(opposite) != direction + } + pub(crate) fn diode_update_neighbors_in_front(&mut self, pos: BlockPos, state: BlockStateId) { + let direction = self.b.facing(state); + let opposite_pos = rel(pos, direction.opposite()); + let block = self.b.block(state); + self.neighbor_changed_at(opposite_pos, block); + self.update_neighbors_at_except(opposite_pos, block, direction); + } + fn comparator_calculate_output(&self, pos: BlockPos, state: BlockStateId) -> i32 { + let input = self.diode_input_signal(pos, state); + if input == 0 { + return 0; + } + let alternate = self.diode_alternate_signal(pos, state); + if alternate > input { + 0 + } else if self.b.table.text(state, self.b.props.mode) == "subtract" { + input - alternate + } else { + input + } + } + /// `DiodeBlock.checkTickOnNeighbor` (and the comparator override). + pub(crate) fn diode_check_tick_on_neighbor(&mut self, pos: BlockPos, state: BlockStateId) { + let block = self.b.block(state); + if self.b.instance_of(state, Class::Comparator) { + if !self.ticks.will_block_tick_this_tick(pos, block) { + let output = self.comparator_calculate_output(pos, state); + let old = self.comparator_output(pos); + if output != old || self.b.table.bool(state, self.b.props.powered) != self.diode_should_turn_on(pos, state) { + let priority = if self.diode_should_prioritize(pos, state) { TickPriority::High } else { TickPriority::Normal }; + self.schedule_tick_priority(pos, block, 2, priority); + } + } + return; + } + if self.diode_is_locked(pos, state) { + return; + } + let on = self.b.table.bool(state, self.b.props.powered); + let should = self.diode_should_turn_on(pos, state); + if on != should && !self.ticks.will_block_tick_this_tick(pos, block) { + let priority = if self.diode_should_prioritize(pos, state) { + TickPriority::ExtremelyHigh + } else if on { + TickPriority::VeryHigh + } else { + TickPriority::High + }; + let delay = self.diode_delay(state); + self.schedule_tick_priority(pos, block, delay, priority); + } + } + /// `DiodeBlock.tick` / `ComparatorBlock.tick`. + pub(crate) fn diode_tick(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + if b.instance_of(state, Class::Comparator) { + self.comparator_refresh(pos, state); + return; + } + if self.diode_is_locked(pos, state) { + return; + } + let on = b.table.bool(state, b.props.powered); + let should = self.diode_should_turn_on(pos, state); + if on && !should { + self.set_block(pos, b.table.set_bool(state, b.props.powered, false), 2); + } else if !on { + self.set_block(pos, b.table.set_bool(state, b.props.powered, true), 2); + if !should { + let delay = self.diode_delay(state); + self.schedule_tick_priority(pos, b.block(state), delay, TickPriority::VeryHigh); + } + } + } + pub(crate) fn comparator_refresh(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + let output = self.comparator_calculate_output(pos, state); + let old = self.ticks.comparator_outputs.insert(pos, output).unwrap_or(0); + if old != output || b.table.text(state, b.props.mode) == "compare" { + let should = self.diode_should_turn_on(pos, state); + let on = b.table.bool(state, b.props.powered); + if on && !should { + self.set_block(pos, b.table.set_bool(state, b.props.powered, false), 2); + } else if !on && should { + self.set_block(pos, b.table.set_bool(state, b.props.powered, true), 2); + } + self.diode_update_neighbors_in_front(pos, state); + } + } + /// `DiodeBlock.neighborChanged`. + pub(crate) fn diode_neighbor_changed(&mut self, pos: BlockPos, state: BlockStateId) { + let block = self.b.block(state); + if !self.b.is_block(self.state(pos), block) { + return; + } + if self.can_survive(state, pos) { + self.diode_check_tick_on_neighbor(pos, state); + } else { + self.drop_resources(state, pos); + self.remove_block(pos, false); + for direction in Direction::ALL { + self.update_neighbors_at(rel(pos, direction), block); + } + } + } + + /// `getAnalogOutputSignal` for state-only sources; others ask the caller. + pub(crate) fn analog_output(&self, state: BlockStateId, pos: BlockPos, direction: Direction) -> i32 { + let b = self.b; + let p = b.props; + match b.data(state).class { + Class::Beehive => b.table.int(state, p.honey_level), + Class::Cake => (7 - b.table.int(state, p.bites)) * 2, + Class::CandleCake => 14, + Class::Composter | Class::LayeredCauldron => b.table.int(state, p.level), + Class::CopperBulb => { + if b.table.bool(self.state(pos), p.lit) { + 15 + } else { + 0 + } + } + Class::EndPortalFrame => { + if b.table.bool(state, p.eye) { + 15 + } else { + 0 + } + } + Class::LavaCauldron => 3, + Class::RespawnAnchor => { + let charges = b.table.int(state, p.charges); + ((charges - 0) as f32 / 4.0 * 15.0).floor() as i32 + } + Class::CopperGolemStatue => { + let pose = b.table.text(state, p.copper_golem_pose); + ["standing", "sitting", "running", "star"].iter().position(|p| *p == pose).map_or(1, |i| i as i32 + 1) + } + _ => self.level.block_entity_analog_signal(pos, state, direction), + } + } + + // ---- torches ---- + + fn torch_has_neighbor_signal(&self, pos: BlockPos, state: BlockStateId) -> bool { + if self.b.instance_of(state, Class::RedstoneWallTorch) { + let opposite = self.b.facing(state).opposite(); + self.has_signal(rel(pos, opposite), opposite) + } else { + self.has_signal(below(pos), Direction::Down) + } + } + pub(crate) fn torch_notify_neighbors(&mut self, pos: BlockPos, state: BlockStateId) { + let block = self.b.block(state); + for direction in Direction::ALL { + self.update_neighbors_at(rel(pos, direction), block); + } + } + pub(crate) fn torch_neighbor_changed(&mut self, pos: BlockPos, state: BlockStateId) { + let block = self.b.block(state); + if self.b.table.bool(state, self.b.props.lit) == self.torch_has_neighbor_signal(pos, state) + && !self.ticks.will_block_tick_this_tick(pos, block) + { + self.schedule_tick(pos, block, 2); + } + } + fn torch_toggled_too_frequently(&mut self, pos: BlockPos, add: bool) -> bool { + if add { + let time = self.level.game_time(); + self.ticks.torch_toggles.push((pos, time)); + } + self.ticks.torch_toggles.iter().filter(|(p, _)| *p == pos).take(8).count() >= 8 + } + pub(crate) fn torch_tick(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + let signal = self.torch_has_neighbor_signal(pos, state); + let time = self.level.game_time(); + while self.ticks.torch_toggles.first().is_some_and(|(_, when)| time - when > 60) { + self.ticks.torch_toggles.remove(0); + } + if b.table.bool(state, b.props.lit) { + if signal { + self.set_block_and_update(pos, b.table.set_bool(state, b.props.lit, false)); + if self.torch_toggled_too_frequently(pos, true) { + self.level_event(1502, pos, 0); + let block = b.block(self.state(pos)); + self.schedule_tick(pos, block, 160); + } + } + } else if !signal && !self.torch_toggled_too_frequently(pos, false) { + self.set_block_and_update(pos, b.table.set_bool(state, b.props.lit, true)); + } + } + + // ---- observers ---- + + pub(crate) fn observer_start_signal(&mut self, pos: BlockPos, block: BlockId) { + if !self.ticks.has_block_tick(pos, block) { + self.schedule_tick(pos, block, 2); + } + } + pub(crate) fn observer_update_in_front(&mut self, pos: BlockPos, state: BlockStateId) { + let direction = self.b.facing(state); + let opposite = rel(pos, direction.opposite()); + let block = self.b.block(state); + self.neighbor_changed_at(opposite, block); + self.update_neighbors_at_except(opposite, block, direction); + } + pub(crate) fn observer_tick(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + if b.table.bool(state, b.props.powered) { + self.set_block(pos, b.table.set_bool(state, b.props.powered, false), 2); + } else { + self.set_block(pos, b.table.set_bool(state, b.props.powered, true), 2); + self.schedule_tick(pos, b.block(state), 2); + } + self.observer_update_in_front(pos, state); + } + + // ---- buttons, levers, plates ---- + + /// `ButtonBlock/LeverBlock.updateNeighbours`. + pub(crate) fn attached_update_neighbours(&mut self, pos: BlockPos, state: BlockStateId) { + let front = self.face_attached_connected(state).opposite(); + let block = self.b.block(state); + self.update_neighbors_at(pos, block); + self.update_neighbors_at(rel(pos, front), block); + } + pub(crate) fn plate_update_neighbours(&mut self, pos: BlockPos, block: BlockId) { + self.update_neighbors_at(pos, block); + self.update_neighbors_at(below(pos), block); + } + pub(crate) fn plate_signal_for_state(&self, state: BlockStateId) -> i32 { + let b = self.b; + if b.instance_of(state, Class::WeightedPressurePlate) { + b.table.int(state, b.props.power) + } else if b.table.bool(state, b.props.powered) { + 15 + } else { + 0 + } + } + fn plate_signal_strength(&self, pos: BlockPos, state: BlockStateId) -> i32 { + use horizon_core::geometry::{Aabb, Vec3}; + let b = self.b; + let area = Aabb::new( + Vec3::new(f64::from(pos.x) + 0.0625, f64::from(pos.y), f64::from(pos.z) + 0.0625), + Vec3::new(f64::from(pos.x) + 0.9375, f64::from(pos.y) + 0.25, f64::from(pos.z) + 0.9375), + ); + let data = b.data(state); + if data.is(Class::WeightedPressurePlate) { + let max = data.max_weight.max(1); + let count = (self.level.count_entities(area, super::EntityQuery::Everything) as i32).min(max); + if count > 0 { + (count.min(max) as f32 / max as f32 * 15.0).ceil() as i32 + } else { + 0 + } + } else { + let query = if data.set_type.as_ref().is_some_and(|s| s.mobs_only) { + super::EntityQuery::Mobs + } else { + super::EntityQuery::Everything + }; + if self.level.count_entities(area, query) > 0 { 15 } else { 0 } + } + } + /// `BasePressurePlateBlock.checkPressed`. + pub(crate) fn plate_check_pressed(&mut self, pos: BlockPos, state: BlockStateId, old_signal: i32) { + let b = self.b; + let signal = self.plate_signal_strength(pos, state); + let was = old_signal > 0; + let is = signal > 0; + let block = b.block(state); + if old_signal != signal { + let new = if b.instance_of(state, Class::WeightedPressurePlate) { + b.table.set_int(state, b.props.power, signal) + } else { + b.table.set_bool(state, b.props.powered, signal > 0) + }; + self.set_block(pos, new, 2); + self.plate_update_neighbours(pos, block); + } + if let Some(set) = b.data(state).set_type.clone() { + if !is && was { + self.sound(pos, &set.plate_off, 1.0, 1.0); + self.game_event(pos, "minecraft:block_deactivate"); + } else if is && !was { + self.sound(pos, &set.plate_on, 1.0, 1.0); + self.game_event(pos, "minecraft:block_activate"); + } + } + if is { + let delay = if b.instance_of(state, Class::WeightedPressurePlate) { 10 } else { 20 }; + self.schedule_tick(pos, block, delay); + } + } + /// `ButtonBlock.press`. + pub(crate) fn button_press(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + self.set_block_and_update(pos, b.table.set_bool(state, b.props.powered, true)); + self.attached_update_neighbours(pos, state); + let data = b.data(state); + self.schedule_tick(pos, b.block(state), data.ticks_to_stay_pressed); + if let Some(set) = data.set_type.clone() { + self.sound(pos, &set.button_on, 1.0, 1.0); + } + self.game_event(pos, "minecraft:block_activate"); + } + /// `ButtonBlock.checkPressed` with no arrows present. + pub(crate) fn button_tick(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + if !b.table.bool(state, b.props.powered) { + return; + } + self.set_block_and_update(pos, b.table.set_bool(state, b.props.powered, false)); + self.attached_update_neighbours(pos, state); + if let Some(set) = b.data(state).set_type.clone() { + self.sound(pos, &set.button_off, 1.0, 1.0); + } + self.game_event(pos, "minecraft:block_deactivate"); + } + /// `LeverBlock.pull`. + pub(crate) fn lever_pull(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + let state = b.table.cycle(state, b.props.powered); + self.set_block_and_update(pos, state); + self.attached_update_neighbours(pos, state); + let powered = b.table.bool(state, b.props.powered); + self.emit(LevelEvent::Sound { + pos, + sound: "minecraft:block.lever.click".into(), + volume: 0.3, + pitch: if powered { 0.6 } else { 0.5 }, + }); + self.game_event(pos, if powered { "minecraft:block_activate" } else { "minecraft:block_deactivate" }); + } + + // ---- consumers ---- + + pub(crate) fn door_neighbor_changed(&mut self, pos: BlockPos, state: BlockStateId, changed: BlockId) { + let b = self.b; + let p = b.props; + let other = if b.table.text(state, p.half) == "lower" { Direction::Up } else { Direction::Down }; + let signal = self.has_neighbor_signal(pos) || self.has_neighbor_signal(rel(pos, other)); + if b.block(state) != changed && signal != b.table.bool(state, p.powered) { + if signal != b.table.bool(state, p.open) { + self.door_sound(pos, state, signal); + self.game_event(pos, if signal { "minecraft:block_open" } else { "minecraft:block_close" }); + } + let next = b.table.set_bool(b.table.set_bool(state, p.powered, signal), p.open, signal); + self.set_block(pos, next, 2); + } + } + pub(crate) fn door_sound(&mut self, pos: BlockPos, state: BlockStateId, open: bool) { + if let Some(set) = self.b.data(state).set_type.clone() { + let pitch = self.random().next_float() * 0.1 + 0.9; + let sound = if open { set.door_open.clone() } else { set.door_close.clone() }; + self.sound(pos, &sound, 1.0, pitch); + } + } + pub(crate) fn trapdoor_sound(&mut self, pos: BlockPos, state: BlockStateId, open: bool) { + if let Some(set) = self.b.data(state).set_type.clone() { + let pitch = self.random().next_float() * 0.1 + 0.9; + let sound = if open { set.trapdoor_open.clone() } else { set.trapdoor_close.clone() }; + self.sound(pos, &sound, 1.0, pitch); + self.game_event(pos, if open { "minecraft:block_open" } else { "minecraft:block_close" }); + } + } + pub(crate) fn trapdoor_neighbor_changed(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + let p = b.props; + let signal = self.has_neighbor_signal(pos); + if signal != b.table.bool(state, p.powered) { + let mut state = state; + if b.table.bool(state, p.open) != signal { + state = b.table.set_bool(state, p.open, signal); + self.trapdoor_sound(pos, state, signal); + } + self.set_block(pos, b.table.set_bool(state, p.powered, signal), 2); + if b.is_waterlogged(state) { + self.schedule_water_tick(pos); + } + } + } + pub(crate) fn gate_neighbor_changed(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + let p = b.props; + let power = self.has_neighbor_signal(pos); + if b.table.bool(state, p.powered) != power { + let next = b.table.set_bool(b.table.set_bool(state, p.powered, power), p.open, power); + self.set_block(pos, next, 2); + if b.table.bool(state, p.open) != power { + let data = b.data(state); + let sound = if power { data.gate_open.clone() } else { data.gate_close.clone() }; + let pitch = self.random().next_float() * 0.1 + 0.9; + if let Some(sound) = sound { + self.sound(pos, &sound, 1.0, pitch); + } + self.game_event(pos, if power { "minecraft:block_open" } else { "minecraft:block_close" }); + } + } + } + pub(crate) fn lamp_neighbor_changed(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + let lit = b.table.bool(state, b.props.lit); + if lit != self.has_neighbor_signal(pos) { + if lit { + self.schedule_tick(pos, b.block(state), 4); + } else { + self.set_block(pos, b.table.cycle(state, b.props.lit), 2); + } + } + } + pub(crate) fn lamp_tick(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + if b.table.bool(state, b.props.lit) && !self.has_neighbor_signal(pos) { + self.set_block(pos, b.table.cycle(state, b.props.lit), 2); + } + } + /// `CopperBulbBlock.checkAndFlip`. + pub(crate) fn copper_bulb_check(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + let p = b.props; + let signal = self.has_neighbor_signal(pos); + if signal != b.table.bool(state, p.powered) { + let mut next = state; + if !b.table.bool(state, p.powered) { + next = b.table.cycle(next, p.lit); + let sound = if b.table.bool(next, p.lit) { + "minecraft:block.copper_bulb.turn_on" + } else { + "minecraft:block.copper_bulb.turn_off" + }; + self.emit(LevelEvent::Sound { + pos, + sound: sound.into(), + volume: 1.0, + pitch: 1.0, + }); + } + self.set_block(pos, b.table.set_bool(next, p.powered, signal), 3); + } + } + /// `NoteBlock.playNote` (block event; instrument pitch from `note`). + pub(crate) fn note_play(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + let instrument = b.table.text(state, b.props.instrument).to_owned(); + let mob_head = super::data::INSTRUMENTS.iter().position(|n| *n == instrument).is_some_and(|i| super::data::instrument_works_above(i as u8)); + if mob_head || b.is_air(self.above_state(pos)) { + let note = b.table.int(state, b.props.note); + let pitch = if mob_head { 1.0 } else { 2f64.powf(f64::from(note - 12) / 12.0) as f32 }; + let sound = match instrument.as_str() { + "custom_head" => "minecraft:ui.button.click".to_owned(), + "dragon" => "minecraft:block.note_block.imitate.ender_dragon".to_owned(), + name if mob_head => format!("minecraft:block.note_block.imitate.{name}"), + name => format!("minecraft:block.note_block.{name}"), + }; + self.emit(LevelEvent::Sound { + pos, + sound: sound.into(), + volume: 3.0, + pitch, + }); + self.game_event(pos, "minecraft:note_block_play"); + } + } + pub(crate) fn note_neighbor_changed(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + let signal = self.has_neighbor_signal(pos); + if signal != b.table.bool(state, b.props.powered) { + if signal { + self.note_play(pos, state); + } + self.set_block_and_update(pos, b.table.set_bool(state, b.props.powered, signal)); + } + } + /// `TntBlock.prime` then `removeBlock`. + pub(crate) fn tnt_check(&mut self, pos: BlockPos) { + if self.has_neighbor_signal(pos) { + self.emit(LevelEvent::PrimeTnt { pos }); + self.remove_block(pos, false); + } + } + pub(crate) fn dispenser_neighbor_changed(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + let trigger = self.has_neighbor_signal(pos) || self.has_neighbor_signal(above(pos)); + let triggered = b.table.bool(state, b.props.triggered); + if trigger && !triggered { + self.schedule_tick(pos, b.block(state), 4); + self.set_block(pos, b.table.set_bool(state, b.props.triggered, true), 2); + } else if !trigger && triggered { + self.set_block(pos, b.table.set_bool(state, b.props.triggered, false), 2); + } + } + pub(crate) fn hopper_check_powered(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + let enabled = !self.has_neighbor_signal(pos); + if enabled != b.table.bool(state, b.props.enabled) { + self.set_block(pos, b.table.set_bool(state, b.props.enabled, enabled), 2); + } + } + pub(crate) fn skull_neighbor_changed(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + let signal = self.has_neighbor_signal(pos); + if signal != b.table.bool(state, b.props.powered) { + self.set_block(pos, b.table.set_bool(state, b.props.powered, signal), 2); + } + } + pub(crate) fn bell_neighbor_changed(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + let signal = self.has_neighbor_signal(pos); + if signal != b.table.bool(state, b.props.powered) { + if signal { + self.emit(LevelEvent::Sound { + pos, + sound: "minecraft:block.bell.use".into(), + volume: 2.0, + pitch: 1.0, + }); + self.game_event(pos, "minecraft:block_change"); + } + self.set_block_and_update(pos, b.table.set_bool(state, b.props.powered, signal)); + } + } + pub(crate) fn crafter_neighbor_changed(&mut self, pos: BlockPos, state: BlockStateId) { + let b = self.b; + let trigger = self.has_neighbor_signal(pos); + let triggered = b.table.bool(state, b.props.triggered); + if trigger && !triggered { + self.schedule_tick(pos, b.block(state), 4); + self.set_block(pos, b.table.set_bool(state, b.props.triggered, true), 2); + } else if !trigger && triggered { + let next = b.table.set_bool(b.table.set_bool(state, b.props.triggered, false), b.props.crafting, false); + self.set_block(pos, next, 2); + } + } +} + +/// Order `positions` as a `java.util.HashSet` of capacity 16 would +/// iterate them (bucket index of the spread hash, then insertion order). +fn java_hash_set_order(positions: &mut Vec) { + fn hash(pos: BlockPos) -> i32 { + // Vec3i.hashCode: (y + z * 31) * 31 + x + (pos.y.wrapping_add(pos.z.wrapping_mul(31))).wrapping_mul(31).wrapping_add(pos.x) + } + let mut unique: Vec = Vec::new(); + for pos in positions.iter() { + if !unique.contains(pos) { + unique.push(*pos); + } + } + let buckets = 16; + let bucket = |pos: BlockPos| { + let h = hash(pos); + ((h ^ ((h as u32) >> 16) as i32) & (buckets - 1)) as usize + }; + let mut ordered: Vec<(usize, usize, BlockPos)> = unique.iter().enumerate().map(|(i, p)| (bucket(*p), i, *p)).collect(); + ordered.sort_by_key(|(b, i, _)| (*b, *i)); + *positions = ordered.into_iter().map(|(_, _, p)| p).collect(); +} diff --git a/crates/horizon-world/src/level/ticks.rs b/crates/horizon-world/src/level/ticks.rs index f6b17e047..3aa4bd5e7 100644 --- a/crates/horizon-world/src/level/ticks.rs +++ b/crates/horizon-world/src/level/ticks.rs @@ -19,6 +19,11 @@ pub struct Ticks { /// `Level.randValue`, the LCG behind `getBlockRandomPos`. pub random_tick_value: i32, pub(crate) updater: NeighborUpdater, + /// `ComparatorBlockEntity.output` per comparator position (block-entity + /// state owned by the level; persist it with the chunk if desired). + pub comparator_outputs: std::collections::HashMap, + /// `RedstoneTorchBlock.RECENT_TOGGLES` (position, game time). + pub torch_toggles: Vec<(BlockPos, i64)>, } impl Default for Ticks { fn default() -> Self { @@ -35,6 +40,8 @@ impl Ticks { sub_tick: 0, random_tick_value: random_tick_seed, updater: NeighborUpdater::default(), + comparator_outputs: Default::default(), + torch_toggles: Vec::new(), } } /// Register a loaded chunk's saved block and fluid ticks.