Merge pull request #122 from ludovic111/fix/nether-portals-94

Nether portals: vanilla timing and linking; items and mobs travel
This commit is contained in:
Ludovic Marie
2026-10-14 18:15:59 +02:00
committed by GitHub
18 changed files with 2191 additions and 154 deletions
@@ -245,6 +245,10 @@ fn main() -> Result<()> {
)?;
// The oracle runs block-inside effects only in "snow_tick".
player.block_effects = false;
// Entity.portalCooldown and portalProcess, and the entry of the last
// portal_tick that went through.
let mut portal = horizon_client::nether_portal::PortalState::default();
let mut travel: Option<horizon_core::position::BlockPos> = None;
for op in f["ops"].as_array().unwrap() {
let mut world = MotionWorld {
player: &mut player,
@@ -442,6 +446,14 @@ fn main() -> Result<()> {
world.player.freeze_immune = boots;
}
"frozen" => world.player.ticks_frozen = op["value"].as_i64().unwrap() as i32,
"portal_tick" => {
// Entity.handlePortal without the destination: players wait
// the creative delay (0) when invulnerable, else 80 ticks.
let creative = op["creative"].as_bool().unwrap();
let transition = if creative { 0 } else { 80 };
let alive = !world.player.health.dead_or_dying();
travel = portal.handle(alive, transition, 10);
}
"weaving" => world.player.status.weaving = op["value"].as_bool().unwrap(),
"flying" => {
let flying = op["value"].as_bool().unwrap();
@@ -515,6 +527,14 @@ fn main() -> Result<()> {
}
_ => return Err("unknown motion operation".into()),
}
// NetherPortalBlock.entityInside: canUsePortal, setAsInsidePortal.
for e in &player.events {
if let MotionEvent::InsidePortal { pos } = e
&& !player.health.dead_or_dying()
{
portal.set_inside(*pos, 10);
}
}
let check_block = scene.block(25, 3, 25);
snapshot(&mut out, &player)?;
let stuck = player.stuck_multiplier;
@@ -529,6 +549,18 @@ fn main() -> Result<()> {
stuck.y.to_bits(),
stuck.z.to_bits()
)?;
writeln!(
out,
"portal {} {} {}",
portal.cooldown,
portal.process.map_or("none".into(), |p| format!(
"{},{},{} {} {}",
p.entry.x, p.entry.y, p.entry.z, p.time, p.inside
)),
travel
.take()
.map_or("-".into(), |t| format!("{},{},{}", t.x, t.y, t.z))
)?;
let h = &player.health;
let canonical = |v: f32| {
if v.is_nan() {
+2 -2
View File
@@ -29,10 +29,10 @@ pub fn position(tag: &Tag) -> Option<Vec3> {
pub fn uuid(tag: &Tag) -> Option<[i32; 4]> {
uuid_from_tag(tag.get("UUID"))
}
fn motion(tag: &Tag) -> Vec3 {
pub fn motion(tag: &Tag) -> Vec3 {
read_doubles::<3>(tag.get("Motion")).map_or(Vec3::ZERO, |m| Vec3::new(m[0], m[1], m[2]))
}
fn rotation(tag: &Tag) -> [f32; 2] {
pub fn rotation(tag: &Tag) -> [f32; 2] {
read_doubles::<2>(tag.get("Rotation")).map_or([0.0; 2], |r| [r[0] as f32, r[1] as f32])
}
fn flag(tag: &Tag, key: &str) -> bool {
+16 -138
View File
@@ -70,6 +70,7 @@ mod names;
mod natural_spawning;
mod nautili;
mod net_harness;
mod nether_portal;
mod options;
mod packs;
mod paintings;
@@ -765,8 +766,8 @@ struct Game<'a> {
world_root: PathBuf,
/// A player carried through a portal, re-placed once the destination loads.
travelling: Option<(PlayerMotion, Vec3)>,
portal_ticks: u32,
portal_cooldown: u32,
/// Nether portals: the player's, items' and mobs' (game/nether_portal.rs).
portals: nether_portal::Portals,
/// The pending travel goes through an End portal (EndPortalBlock destinations).
end_travel: bool,
/// The next enter_dimension call comes from an End portal.
@@ -2836,6 +2837,7 @@ impl Game<'_> {
}
MotionEvent::Snowflake { position, velocity } => self.snowflake(position, velocity),
MotionEvent::EnterBlock { state } => self.trigger_enter_block(state),
MotionEvent::InsidePortal { pos } => self.player_inside_nether_portal(pos),
_ => {}
}
}
@@ -2923,6 +2925,7 @@ impl Game<'_> {
horizon_client::spans::time("tick_rockets", || self.tick_rockets());
}
if running {
horizon_client::spans::time("entity_portals", || self.handle_entity_portals());
horizon_client::spans::time("tick_items", || self.tick_items());
}
horizon_client::spans::time("spawn_loaded_entities", || self.spawn_loaded_entities());
@@ -2930,11 +2933,15 @@ impl Game<'_> {
horizon_client::spans::time("tick_mobs", || self.tick_mobs())?;
horizon_client::spans::time("recheck_golem_openers", || self.recheck_golem_openers());
horizon_client::spans::time("tick_experience", || self.tick_experience());
horizon_client::spans::time("entity_portals", || {
self.find_entity_portals();
self.resolve_arrivals();
});
}
horizon_client::spans::time("tick_lan", || self.tick_lan());
horizon_client::spans::time("tick_hand", || self.tick_hand());
horizon_client::spans::time("tick_sleep", || self.tick_sleep());
horizon_client::spans::time("tick_portal", || self.tick_portal())?;
horizon_client::spans::time("tick_portal", || self.tick_nether_portal())?;
if running {
horizon_client::spans::time("tick_end", || self.tick_end())?;
}
@@ -5546,6 +5553,7 @@ impl Game<'_> {
self.player_spawn = None;
self.mobs.clear();
self.creatures.reset_trader();
self.portals = Default::default();
self.arrows.clear();
self.dropped.clear();
self.particles.clear();
@@ -5703,7 +5711,6 @@ impl Game<'_> {
self.orbs.clear();
self.mining = None;
self.travelling = Some((player, destination));
self.portal_cooldown = 300;
self.end_travel = (target == Dim::End || from_end) && self.end_portal_travel;
if let Some(r) = self.renderer.as_mut() {
r.clear_sections();
@@ -5812,138 +5819,9 @@ impl Game<'_> {
}
Ok(false)
}
/// PortalForcer: reuse a nearby portal, else build a 2x3 obsidian portal.
fn place_after_travel(&mut self, mut player: PlayerMotion, target: Vec3) -> Result<()> {
let (tx, tz) = (target.x.floor() as i32, target.z.floor() as i32);
let radius = if self.dim == Dim::Nether { 16 } else { 32 };
let (min_y, max_y) = if self.dim == Dim::Nether {
(1, 126)
} else {
(MIN_Y + 1, MIN_Y + HEIGHT - 3)
};
let portal_name = "minecraft:nether_portal";
let mut best: Option<(i64, [i32; 3])> = None;
for z in tz - radius..=tz + radius {
for x in tx - radius..=tx + radius {
if !self.world.loaded(x, z) {
continue;
}
for y in min_y..max_y {
if &*self.res.facts.get(self.world.block(x, y, z)).name == portal_name
&& &*self.res.facts.get(self.world.block(x, y - 1, z)).name != portal_name
{
let d = i64::from(x - tx).pow(2)
+ i64::from(z - tz).pow(2)
+ i64::from(y - target.y as i32).pow(2);
if best.is_none_or(|b| d < b.0) {
best = Some((d, [x, y, z]));
}
}
}
}
}
let spot = match best {
Some((_, p)) => p,
None => {
// Build: obsidian frame 4 wide, 5 tall, with a floor, carved into the terrain.
let y = (target.y.floor() as i32).clamp(min_y + 1, max_y - 5);
let set = |g: &mut Self, p: [i32; 3], name: &str| -> Result<()> {
if let Some(id) = g.res.assets.registry.default_state(name) {
g.world.set(p[0], p[1], p[2], id)?;
}
Ok(())
};
for dz in -1..=1 {
for dx in -1..=2 {
set(self, [tx + dx, y - 1, tz + dz], "minecraft:obsidian")?;
for dy in 0..4 {
set(self, [tx + dx, y + dy, tz + dz], "minecraft:air")?;
}
}
}
for w in -1..=2 {
for h in -1..=3 {
if w == -1 || w == 2 || h == -1 || h == 3 {
set(self, [tx + w, y + h, tz], "minecraft:obsidian")?;
}
}
}
self.try_light_portal([tx, y, tz])?;
[tx, y, tz]
}
};
player.position = Vec3::new(
f64::from(spot[0]) + 0.5,
f64::from(spot[1]),
f64::from(spot[2]) + 0.5,
);
player.velocity = Vec3::ZERO;
self.previous_position = player.position;
self.player = Some(player);
self.sway = Default::default();
self.apply_equipment();
let at = [f64::from(spot[0]), f64::from(spot[1]), f64::from(spot[2])];
self.audio
.play("minecraft:block.portal.travel", Some(at), 0.25, 1.0);
Ok(())
}
fn tick_portal(&mut self) -> Result<()> {
let Some(p) = self.player.as_ref() else {
return Ok(());
};
let w = f64::from(p.dimensions.width) / 2.0;
let (lo, hi) = (
[p.position.x - w, p.position.y, p.position.z - w],
[
p.position.x + w,
p.position.y + f64::from(p.dimensions.height),
p.position.z + w,
],
);
let mut inside = false;
for x in lo[0].floor() as i32..=hi[0].floor() as i32 {
for y in lo[1].floor() as i32..=hi[1].floor() as i32 {
for z in lo[2].floor() as i32..=hi[2].floor() as i32 {
if &*self.res.facts.get(self.world.block(x, y, z)).name
== "minecraft:nether_portal"
{
inside = true;
}
}
}
}
if !inside {
self.portal_ticks = 0;
self.portal_cooldown = self.portal_cooldown.saturating_sub(1);
return Ok(());
}
if self.portal_cooldown > 0 {
return Ok(());
}
if self.portal_ticks == 0 {
let at = self.eye_position();
self.audio.play(
"minecraft:block.portal.trigger",
at,
0.25,
self.world.random.next_float() * 0.4 + 0.8,
);
}
self.portal_ticks += 1;
// Player.getPortalWaitTime: 80 ticks, or 1 when invulnerable (creative).
let wait = if self.creative { 1 } else { 80 };
if self.portal_ticks >= wait {
self.portal_ticks = 0;
// NetherPortalBlock: the Nether leads to the Overworld, anywhere else to the Nether.
let target = if self.dim == Dim::Nether {
Dim::Overworld
} else {
Dim::Nether
};
self.end_portal_travel = false;
self.enter_dimension(target)?;
}
Ok(())
/// Arrival through a nether portal, once the destination is loaded.
fn place_after_travel(&mut self, player: PlayerMotion, target: Vec3) -> Result<()> {
self.arrive_through_nether_portal(player, target)
}
/// Leaving the game with a world open (window closed, Quit, `quit`):
/// menu items go back (Player.closeContainer), then the world is saved,
@@ -7505,6 +7383,7 @@ impl Game<'_> {
self.save_raids();
self.save_fight();
self.save_wandering_trader();
self.save_portal_arrivals();
self.save_stats();
self.save_advancements();
self.save_scoreboard();
@@ -9007,8 +8886,7 @@ pub fn run() -> Result<()> {
dim: Dim::Overworld,
world_root: PathBuf::new(),
travelling: None,
portal_ticks: 0,
portal_cooldown: 0,
portals: Default::default(),
end_travel: false,
end_portal_travel: false,
end: Default::default(),
+4 -4
View File
@@ -389,7 +389,7 @@ impl Game<'_> {
}
}
if portal {
if self.portal_cooldown == 0 {
if self.portals.player.cooldown == 0 {
let target = if self.dim == Dim::End {
Dim::Overworld
} else {
@@ -400,10 +400,10 @@ impl Game<'_> {
self.end_portal_travel = false;
result?;
// Player.getDimensionChangingDelay.
self.portal_cooldown = 10;
self.portals.player.cooldown = 10;
} else {
// Entity.setAsInsidePortal while cooling down restarts the cooldown.
self.portal_cooldown = 10;
self.portals.player.cooldown = 10;
}
} else if let Some(g) = gateway
&& self.end.gateway_cooldown == 0
@@ -440,7 +440,7 @@ impl Game<'_> {
) -> Result<()> {
self.end_travel = false;
// Player.getDimensionChangingDelay (enter_dimension uses the Nether portal value).
self.portal_cooldown = 10;
self.portals.player.cooldown = 10;
if player.health.dead_or_dying() {
// Respawning out of the End: a fresh player at the spawn.
player = PlayerMotion::new(self.motion, target)?;
@@ -0,0 +1,722 @@
//! Nether portals for the player and the other entities:
//! `Entity.setAsInsidePortal` / `handlePortal` with `PortalProcessor`,
//! `NetherPortalBlock.getPortalTransitionTime` and `getPortalDestination`
//! (`PortalForcer` through `horizon_world::level::portal_travel`), and
//! `LocalPlayer.handlePortalTransitionEffect`.
//!
//! Only one dimension is loaded at a time. The player's destination is found
//! once the other dimension has loaded around it. An item or mob that goes
//! through waits as an `Arrival` (its saved compound and where it stood in its
//! portal) until the player is in that dimension and its exit is loaded.
use super::{Dim, Game, Screen};
use horizon_client::Result;
use horizon_client::nether_portal::PortalState;
use horizon_core::{
geometry::{Axis, Vec3},
position::BlockPos,
random::RandomSource,
};
use horizon_world::{
level::portal_travel::{
BorderBounds, FoundRectangle, closest_portal, collision_free_position, exit_position,
largest_rectangle_around, relative_position,
},
nbt::Tag,
};
use std::collections::HashMap;
/// `Player.getDimensionChangingDelay`.
pub(super) const PLAYER_DELAY: i32 = 10;
/// `Entity.getDimensionChangingDelay`.
const ENTITY_DELAY: i32 = 300;
/// Where in its portal a traveller stood, and where its exit is to be found.
#[derive(Clone, Copy, Debug)]
pub(super) struct Plan {
pub(super) dim: Dim,
/// The border-clamped, scaled position (`approximateExitPos`).
pub(super) approximate: BlockPos,
entry_x_axis: bool,
offset: Vec3,
width: f32,
height: f32,
}
/// An entity on its way to a dimension that isn't loaded.
#[derive(Clone, Debug)]
struct Arrival {
plan: Plan,
tag: Tag,
}
/// The nether portal state of the world (`Game::portals`).
#[derive(Default)]
pub(super) struct Portals {
/// The player's.
pub(super) player: PortalState,
/// The player's travel, while the destination loads.
pub(super) travel: Option<Plan>,
/// `LocalPlayer.portalProcess.isInsidePortalThisTick`.
client_inside: bool,
/// Items and mobs, by entity id.
entities: HashMap<u32, PortalState>,
/// Positions before this tick's moves, by entity id.
before: HashMap<u32, Vec3>,
arrivals: Vec<Arrival>,
loaded: bool,
dirty: bool,
}
fn rotate_y(v: Vec3, degrees: f32) -> Vec3 {
// Vec3.yRot((float)Math.toRadians(degrees))
let angle = f64::from(degrees.to_radians());
let (cos, sin) = (
f64::from(horizon_core::geometry::trig::cos(angle)),
f64::from(horizon_core::geometry::trig::sin(angle)),
);
Vec3::new(v.x * cos + v.z * sin, v.y, v.z * cos - v.x * sin)
}
fn doubles(values: [f64; 3]) -> Tag {
Tag::List(values.iter().map(|v| Tag::Double(v.to_bits())).collect())
}
impl Game<'_> {
/// The world border's extent.
fn border_bounds(&self) -> BorderBounds {
let [min_x, min_z, max_x, max_z] = self.border.bounds();
BorderBounds {
min_x,
min_z,
max_x,
max_z,
}
}
/// `ServerLevel.isAllowedToEnterPortal`.
fn may_enter(&self, target: Dim) -> bool {
target != Dim::Nether || self.ui.rules.bool("allow_entering_nether_using_portals")
}
/// The plan of an entity of `width` by `height` at `at` going through the
/// portal at `entry` (`getDimensionTransitionFromExit` and the scaled,
/// clamped exit of `getPortalDestination`).
fn portal_plan(
&self,
entry: BlockPos,
at: Vec3,
width: f32,
height: f32,
reset_forward: bool,
) -> Plan {
let target = if self.dim == Dim::Nether {
Dim::Overworld
} else {
Dim::Nether
};
let state = self.world.block(entry.x, entry.y, entry.z);
let b = &self.res.behaviours;
let (entry_x_axis, offset) = match b.portal_axis(state) {
Some(x_axis) => {
let area = largest_rectangle_around(
entry,
if x_axis { Axis::X } else { Axis::Z },
21,
Axis::Y,
21,
|p| self.world.block(p.x, p.y, p.z) == state,
);
let mut offset = relative_position(area, x_axis, at, width, height);
if reset_forward {
offset.z = 0.0;
}
(x_axis, offset)
}
None => (true, Vec3::new(0.5, 0.0, 0.0)),
};
// DimensionType.getTeleportationScale: 8 out of the Nether, 1/8 into it.
let scale = if self.dim == Dim::Nether {
8.0
} else {
1.0 / 8.0
};
Plan {
dim: target,
approximate: self.border_bounds().clamp(at.x * scale, at.y, at.z * scale),
entry_x_axis,
offset,
width,
height,
}
}
/// The nether portal blocks of the chunks within `radius` of `center`
/// (the points of interest `PortalForcer` searches): loaded chunks as
/// they are, the others as saved; chunks never generated have none.
fn portal_blocks(&self, center: BlockPos, radius: i32) -> Vec<BlockPos> {
let b = &self.res.behaviours;
let chunk_radius = radius.div_euclid(16) + 1;
let (cx, cz) = (center.x >> 4, center.z >> 4);
let mut out = Vec::new();
for z in cz - chunk_radius..=cz + chunk_radius {
for x in cx - chunk_radius..=cx + chunk_radius {
let saved;
let chunk = match self.world.chunks.get(&(x, z)) {
Some(c) => &**c,
None => match self
.save
.load(x, z, self.res.assets.registry, &self.res.biomes)
{
Some(c) => {
saved = c;
&saved
}
None => continue,
},
};
for (s, section) in chunk.sections.iter().enumerate() {
if !section.blocks.maybe_has(|v| {
b.portal_axis(horizon_world::registry::BlockStateId(v))
.is_some()
}) {
continue;
}
let base = horizon_client::chunk::MIN_Y + 16 * s as i32;
for y in base..base + 16 {
for lz in 0..16 {
for lx in 0..16 {
let (wx, wz) = (x * 16 + lx, z * 16 + lz);
if b.portal_axis(chunk.block(wx, y, wz)).is_some() {
out.push(BlockPos::new(wx, y, wz));
}
}
}
}
}
}
}
out
}
/// The exit portal of `plan` in the loaded dimension: the closest one
/// within reach, else one built by `PortalForcer.createPortal`.
fn nether_exit_portal(&mut self, plan: &Plan) -> Option<FoundRectangle> {
let to_nether = plan.dim == Dim::Nether;
let radius = if to_nether { 16 } else { 128 };
let border = self.border_bounds();
let portals = self.portal_blocks(plan.approximate, radius);
let (min_section, max_section) = if to_nether { (0, 15) } else { (-4, 19) };
let found = closest_portal(
&portals,
plan.approximate,
to_nether,
&border,
min_section,
max_section,
);
if let Some(found) = found {
let state = self.world.block(found.x, found.y, found.z);
let x_axis = self.res.behaviours.portal_axis(state).unwrap_or(true);
return Some(largest_rectangle_around(
found,
if x_axis { Axis::X } else { Axis::Z },
21,
Axis::Y,
21,
|p| self.world.block(p.x, p.y, p.z) == state,
));
}
let logical = if to_nether { 128 } else { 384 };
let (approximate, x_axis) = (plan.approximate, plan.entry_x_axis);
let created = self.with_level(|b, level, ticks| {
b.create_portal(level, ticks, approximate, x_axis, &border, logical)
});
let _ = self.process_level_events();
created
}
/// `NetherPortalBlock.createDimensionTransition`: the arrival position
/// and the yaw turned by.
fn arrival(&self, plan: &Plan, exit: FoundRectangle) -> (Vec3, f32) {
let b = &self.res.behaviours;
let corner = exit.min_corner;
let exit_x_axis = b
.portal_axis(self.world.block(corner.x, corner.y, corner.z))
.unwrap_or(true);
let (bottom, rotation) = exit_position(
exit,
exit_x_axis,
plan.entry_x_axis,
plan.offset,
plan.width,
plan.height,
);
let border = self.border_bounds();
let at = collision_free_position(bottom, plan.width, plan.height, &border, |p| {
b.collision_shape(self.world.block(p.x, p.y, p.z))
.map(|s| s.moved(Vec3::new(f64::from(p.x), f64::from(p.y), f64::from(p.z))))
});
(at, rotation)
}
// ---- the player ----
/// `NetherPortalBlock.entityInside` for the player: `canUsePortal`, then
/// `setAsInsidePortal` (and the client's own, which drives the effect).
pub(super) fn player_inside_nether_portal(&mut self, pos: BlockPos) {
let alive = self
.player
.as_ref()
.is_some_and(|p| !p.health.dead_or_dying());
if !alive || self.riding.is_some() || self.sleeping.is_some() {
return;
}
self.portals.player.set_inside(pos, PLAYER_DELAY);
self.portals.client_inside = true;
}
/// `ServerPlayer.handlePortal` (not while changing dimension: there is no
/// player then). Players wait `players_nether_portal_default_delay`
/// ticks, or the creative delay with invulnerable abilities.
pub(super) fn tick_nether_portal(&mut self) -> Result<()> {
// A server's portals are its own.
if self.remote.is_some() {
return Ok(());
}
let Some(p) = self.player.as_ref() else {
return Ok(());
};
if self.travelling.is_some() {
return Ok(());
}
let allowed = !p.health.dead_or_dying() && self.riding.is_none() && self.sleeping.is_none();
let rule = if p.invulnerable {
"players_nether_portal_creative_delay"
} else {
"players_nether_portal_default_delay"
};
let transition = self.ui.rules.int(rule).max(0);
let Some(entry) = self
.portals
.player
.handle(allowed, transition, PLAYER_DELAY)
else {
return Ok(());
};
let Some(p) = self.player.as_ref() else {
return Ok(());
};
let plan = self.portal_plan(
entry,
p.position,
p.dimensions.width,
p.dimensions.height,
true,
);
if !self.may_enter(plan.dim) {
return Ok(());
}
self.portals.travel = Some(plan);
self.end_portal_travel = false;
self.enter_dimension(plan.dim)?;
// The destination is all on disk now: load around the portal its
// points of interest lead to, or the approximate exit.
let to_nether = plan.dim == Dim::Nether;
let portals = self.portal_blocks(plan.approximate, if to_nether { 16 } else { 128 });
let (min_section, max_section) = if to_nether { (0, 15) } else { (-4, 19) };
let border = self.border_bounds();
let found = closest_portal(
&portals,
plan.approximate,
to_nether,
&border,
min_section,
max_section,
);
let centre = found.unwrap_or(plan.approximate);
if let Some((_, target)) = self.travelling.as_mut() {
*target = Vec3::new(
f64::from(centre.x) + 0.5,
f64::from(centre.y),
f64::from(centre.z) + 0.5,
);
}
Ok(())
}
/// The player's arrival once the destination has loaded around the
/// approximate exit: the waiting entities first, then the exit portal
/// (found or built), the position in it, the turned yaw and motion, and
/// `TeleportTransition.PLAY_PORTAL_SOUND` (level event 1032).
pub(super) fn arrive_through_nether_portal(
&mut self,
mut player: horizon_client::motion::PlayerMotion,
target: Vec3,
) -> Result<()> {
self.resolve_arrivals();
let plan = self.portals.travel.take();
let exit = plan.as_ref().and_then(|plan| self.nether_exit_portal(plan));
let (position, rotation) = match (plan, exit) {
(Some(plan), Some(exit)) => self.arrival(&plan, exit),
_ => (target, 0.0),
};
player.position = position;
// Relative.ROTATION and Relative.DELTA: the yaw turns, the motion
// turns with it.
player.yaw += rotation;
player.head_yaw += rotation;
self.yaw += rotation;
player.velocity = rotate_y(player.velocity, -rotation);
self.previous_position = player.position;
self.player = Some(player);
self.sway = Default::default();
self.apply_equipment();
let pitch = self.world.random.next_float() * 0.4 + 0.8;
self.audio
.play("minecraft:block.portal.travel", None, 0.25, pitch);
Ok(())
}
/// `LocalPlayer.handlePortalTransitionEffect`: whether the confusion
/// effect grows this tick. Entering a portal closes screens other than
/// the chat and death screens and plays `block.portal.trigger` when the
/// effect starts from nothing.
pub(super) fn client_portal_effect(&mut self) -> bool {
if !std::mem::take(&mut self.portals.client_inside) {
return false;
}
match self.screen {
Screen::Playing | Screen::Chat | Screen::Dead => {}
Screen::Inventory | Screen::Creative => {
self.close_container();
self.carried = None;
self.screen = Screen::Playing;
self.capture(true);
}
_ => {
self.screen = Screen::Playing;
self.capture(true);
}
}
if self.res.screen_fx.portal == 0.0 {
let pitch = self.world.random.next_float() * 0.4 + 0.8;
self.audio
.play("minecraft:block.portal.trigger", None, 0.25, pitch);
}
true
}
// ---- other entities ----
/// Positions before the entities move this tick, and `Entity.handlePortal`
/// at the start of their tick: an item or mob that stayed in a portal
/// goes through (transition time 0) and waits for its dimension.
pub(super) fn handle_entity_portals(&mut self) {
if self.remote.is_some() {
return;
}
self.load_portal_arrivals();
let mut leaving: Vec<(u32, BlockPos)> = Vec::new();
self.portals.before.clear();
for e in &self.dropped {
self.portals.before.insert(e.id, e.position);
}
for m in &self.mobs {
self.portals.before.insert(m.id, m.position);
}
let ids: Vec<(u32, bool)> = self
.dropped
.iter()
.map(|e| (e.id, true))
.chain(self.mobs.iter().map(|m| (m.id, self.mob_can_use_portal(m))))
.collect();
let present: std::collections::HashSet<u32> = ids.iter().map(|(id, _)| *id).collect();
self.portals.entities.retain(|id, _| present.contains(id));
for (id, allowed) in ids {
let Some(state) = self.portals.entities.get_mut(&id) else {
continue;
};
if let Some(entry) = state.handle(allowed, 0, ENTITY_DELAY) {
leaving.push((id, entry));
}
if state.cooldown == 0 && state.process.is_none() {
self.portals.entities.remove(&id);
}
}
for (id, entry) in leaving {
self.send_through_portal(id, entry);
}
}
/// `Entity.load`: the saved `PortalCooldown` (an entity that just came
/// through stands in its exit portal for 300 ticks without going back).
pub(super) fn restore_portal_cooldown(&mut self, id: u32, tag: &Tag) {
if let Some(Tag::Int(cooldown)) = tag.get("PortalCooldown")
&& *cooldown > 0
{
self.portals.entities.insert(
id,
PortalState {
cooldown: *cooldown,
process: None,
},
);
}
}
/// `canUsePortal(false)` of a mob: alive, riding nothing, not asleep,
/// not carrying the player, and not a boss that never travels.
fn mob_can_use_portal(&self, m: &horizon_client::mobs::Mob) -> bool {
use horizon_client::mobs::Species;
m.alive()
&& m.extra.mount.is_none()
&& self.riding != Some(m.id)
&& m.species() != Species::Wither
}
/// `NetherPortalBlock.entityInside` for the items and mobs that moved this
/// tick: the portal blocks their box swept through.
pub(super) fn find_entity_portals(&mut self) {
if self.remote.is_some() {
return;
}
let mut inside: Vec<(u32, BlockPos)> = Vec::new();
let items: Vec<(u32, Vec3, f32, f32)> = self
.dropped
.iter()
.map(|e| (e.id, e.position, 0.25, 0.25))
.collect();
let mobs: Vec<(u32, Vec3, f32, f32)> = self
.mobs
.iter()
.filter(|m| self.mob_can_use_portal(m))
.map(|m| (m.id, m.position, m.width(), m.height()))
.collect();
for (id, to, width, height) in items.into_iter().chain(mobs) {
let from = self.portals.before.get(&id).copied().unwrap_or(to);
if let Some(pos) = self.swept_portal(from, to, width, height) {
inside.push((id, pos));
}
}
for (id, pos) in inside {
self.portals
.entities
.entry(id)
.or_default()
.set_inside(pos, ENTITY_DELAY);
}
}
/// The first nether portal block an entity box swept through
/// (`Entity.checkInsideBlocks`, whose first portal sets the entry).
fn swept_portal(&self, from: Vec3, to: Vec3, width: f32, height: f32) -> Option<BlockPos> {
let half = f64::from(width) / 2.0;
let bounds = horizon_core::geometry::Aabb::new(
Vec3::new(to.x - half, to.y, to.z - half),
Vec3::new(to.x + half, to.y + f64::from(height), to.z + half),
)
.deflate(Vec3::new(
f64::from(1.0e-5_f32),
f64::from(1.0e-5_f32),
f64::from(1.0e-5_f32),
));
let mut found = None;
let _ = horizon_core::geometry::sweep_intersected_blocks(
from,
to,
bounds,
1_000_000,
|p, _| {
if self
.res
.behaviours
.portal_axis(self.world.block(p.x, p.y, p.z))
.is_some()
{
found = Some(p);
return false;
}
true
},
);
found
}
/// `Entity.teleportCrossDimension` away from the loaded dimension: the
/// entity is saved and removed, and waits for its dimension to load.
fn send_through_portal(&mut self, id: u32, entry: BlockPos) {
if let Some(i) = self.dropped.iter().position(|e| e.id == id) {
let e = &self.dropped[i];
let plan = self.portal_plan(entry, e.position, 0.25, 0.25, false);
if !self.may_enter(plan.dim) {
return;
}
let uuid = self.uuid_for(id);
let tag = horizon_client::entity_nbt::item_entity_to_nbt(
&self.dropped[i],
uuid,
self.persist_raw(id),
);
self.dropped.remove(i);
self.forget_entity(id);
self.portals.arrivals.push(Arrival { plan, tag });
self.portals.dirty = true;
} else if let Some(i) = self.mobs.iter().position(|m| m.id == id) {
let m = &self.mobs[i];
let plan = self.portal_plan(entry, m.position, m.width(), m.height(), true);
if !self.may_enter(plan.dim) {
return;
}
let mut tag = self.mob_tree_nbt(i);
// Entity.removeAfterChangingDimensions drops the leash.
if let Tag::Compound(c) = &mut tag {
c.remove(&"leash".into());
}
let mut gone = vec![id];
let mut k = 0;
while k < gone.len() {
let v = gone[k];
gone.extend(
self.mobs
.iter()
.filter(|m| m.extra.mount == Some(v))
.map(|m| m.id),
);
k += 1;
}
self.mobs.retain(|m| !gone.contains(&m.id));
for g in gone {
self.forget_entity(g);
}
self.portals.arrivals.push(Arrival { plan, tag });
self.portals.dirty = true;
}
}
/// Entities waiting for the loaded dimension whose exit area is loaded:
/// their exit portal (found or built), position, turned yaw and motion,
/// and portal cooldown; they join the world with the chunk entities.
pub(super) fn resolve_arrivals(&mut self) {
if self.remote.is_some() {
return;
}
let mut i = 0;
while i < self.portals.arrivals.len() {
let plan = self.portals.arrivals[i].plan;
let (cx, cz) = (plan.approximate.x >> 4, plan.approximate.z >> 4);
let ready = plan.dim == self.dim
&& (-1..=1).all(|dz| (-1..=1).all(|dx| self.streaming.is_lit(cx + dx, cz + dz)));
if !ready {
i += 1;
continue;
}
let Arrival { plan, mut tag } = self.portals.arrivals.remove(i);
self.portals.dirty = true;
let Some(exit) = self.nether_exit_portal(&plan) else {
continue;
};
let (at, rotation) = self.arrival(&plan, exit);
let motion = rotate_y(horizon_client::entity_nbt::motion(&tag), -rotation);
let [yaw, pitch] = horizon_client::entity_nbt::rotation(&tag);
if let Tag::Compound(c) = &mut tag {
c.insert("Pos".into(), doubles([at.x, at.y, at.z]));
c.insert("Motion".into(), doubles([motion.x, motion.y, motion.z]));
c.insert(
"Rotation".into(),
Tag::List(vec![
Tag::Float((yaw + rotation).to_bits()),
Tag::Float(pitch.to_bits()),
]),
);
// setPortalCooldown before the teleport, copied by restoreFrom.
c.insert("PortalCooldown".into(), Tag::Int(ENTITY_DELAY));
}
let key = ((at.x.floor() as i32) >> 4, (at.z.floor() as i32) >> 4);
match self
.world
.loaded_entities
.iter_mut()
.find(|(k, _)| *k == key)
{
Some((_, tags)) => tags.push(tag),
None => self.world.loaded_entities.push((key, vec![tag])),
}
}
}
// ---- persistence ----
fn arrivals_path(&self) -> std::path::PathBuf {
self.world_root
.join("data")
.join("horizon_portal_arrivals.dat")
}
/// The waiting entities of the open world (read once).
pub(super) fn load_portal_arrivals(&mut self) {
if self.portals.loaded || self.remote.is_some() {
return;
}
self.portals.loaded = true;
let Some(root) = horizon_client::save::read_dat(&self.arrivals_path()) else {
return;
};
let Some(Tag::List(list)) = root.get("arrivals") else {
return;
};
for a in list {
let int = |k: &str| match a.get(k) {
Some(Tag::Int(v)) => Some(*v),
_ => None,
};
let float = |k: &str| match a.get(k) {
Some(Tag::Float(v)) => Some(f32::from_bits(*v)),
_ => None,
};
let double = |k: &str| match a.get(k) {
Some(Tag::Double(v)) => Some(f64::from_bits(*v)),
_ => None,
};
let dim = match horizon_client::save::text(a.get("dimension")).as_deref() {
Some("minecraft:the_nether") => Dim::Nether,
Some(_) => Dim::Overworld,
None => continue,
};
let (Some(x), Some(y), Some(z), Some(tag)) =
(int("x"), int("y"), int("z"), a.get("entity"))
else {
continue;
};
self.portals.arrivals.push(Arrival {
plan: Plan {
dim,
approximate: BlockPos::new(x, y, z),
entry_x_axis: int("x_axis").unwrap_or(1) != 0,
offset: Vec3::new(
double("right").unwrap_or(0.5),
double("up").unwrap_or(0.0),
double("forward").unwrap_or(0.0),
),
width: float("width").unwrap_or(0.25),
height: float("height").unwrap_or(0.25),
},
tag: tag.clone(),
});
}
}
/// Write the waiting entities when they changed.
pub(super) fn save_portal_arrivals(&mut self) {
if !self.portals.dirty || self.remote.is_some() {
return;
}
let list = self
.portals
.arrivals
.iter()
.map(|a| {
let p = &a.plan;
Tag::compound([
("dimension", Tag::String(p.dim.id().into())),
("x", Tag::Int(p.approximate.x)),
("y", Tag::Int(p.approximate.y)),
("z", Tag::Int(p.approximate.z)),
("x_axis", Tag::Int(i32::from(p.entry_x_axis))),
("right", Tag::Double(p.offset.x.to_bits())),
("up", Tag::Double(p.offset.y.to_bits())),
("forward", Tag::Double(p.offset.z.to_bits())),
("width", Tag::Float(p.width.to_bits())),
("height", Tag::Float(p.height.to_bits())),
("entity", a.tag.clone()),
])
})
.collect();
let root = Tag::compound([("arrivals", Tag::List(list))]);
if horizon_client::save::write_dat(&self.arrivals_path(), root).is_ok() {
self.portals.dirty = false;
}
}
}
+7 -1
View File
@@ -440,7 +440,7 @@ impl Game<'_> {
i
}
/// A mob's entity tag with the mobs riding it under `Passengers`.
fn mob_tree_nbt(&mut self, i: usize) -> Tag {
pub(super) fn mob_tree_nbt(&mut self, i: usize) -> Tag {
let id = self.mobs[i].id;
let uuid = self.uuid_for(id);
let mut tag = entity_nbt::mob_to_nbt(&self.mobs[i], uuid, self.persist.raw.get(&id));
@@ -463,11 +463,17 @@ impl Game<'_> {
}
tag
}
/// Forget an entity that left the world (its UUID and loaded compound).
pub(super) fn forget_entity(&mut self, id: u32) {
self.persist.uuids.remove(&id);
self.persist.raw.remove(&id);
}
/// The compound an entity was loaded with (and commands have edited).
pub(super) fn persist_raw(&self, id: u32) -> Option<&Tag> {
self.persist.raw.get(&id)
}
fn remember(&mut self, id: u32, uuid: Option<[i32; 4]>, tag: Tag) {
self.restore_portal_cooldown(id, &tag);
if let Some(u) = uuid {
self.persist.uuids.insert(id, u);
}
@@ -198,7 +198,7 @@ impl Game<'_> {
let eye = self.eye_position();
if let Some(e) = eye {
let brightness = self.eye_brightness(e);
let inside_portal = self.portal_ticks > 0;
let inside_portal = self.client_portal_effect();
self.res.screen_fx.tick(brightness, inside_portal);
// LocalPlayer water vision and AtmosphericFogEnvironment rain fog.
let in_water =
+1
View File
@@ -91,6 +91,7 @@ pub mod multiplayer;
pub mod music;
pub mod nbt_path;
pub mod net;
pub mod nether_portal;
pub mod options_file;
pub mod options_fixes;
pub mod options_horizon;
+9
View File
@@ -138,6 +138,11 @@ pub enum MotionEvent {
EnterBlock {
state: BlockStateId,
},
/// `NetherPortalBlock.entityInside`: the player's box swept through a
/// nether portal block.
InsidePortal {
pos: BlockPos,
},
}
pub struct PlayerMotion {
pub position: Vec3,
@@ -962,6 +967,10 @@ impl MotionWorld<'_, '_, '_> {
}
"minecraft:cobweb" => self.web_inside(),
"minecraft:sweet_berry_bush" => self.sweet_berry_bush_inside(state)?,
"minecraft:nether_portal" => self
.player
.events
.push(MotionEvent::InsidePortal { pos: p }),
_ => {}
}
// ServerPlayer.onInsideBlock
@@ -0,0 +1,76 @@
//! `PortalProcessor` and an entity's portal cooldown
//! (`Entity.setAsInsidePortal` / `handlePortal`) for nether portals.
use horizon_core::position::BlockPos;
/// `PortalProcessor` for a nether portal.
#[derive(Clone, Copy, Debug)]
pub struct Process {
pub entry: BlockPos,
pub time: i32,
pub inside: bool,
}
impl Process {
/// `processPortalTeleportation`: whether the entity goes through now.
pub fn process(&mut self, allowed: bool, transition_time: i32) -> bool {
if !self.inside {
// decayTick
self.time = (self.time - 4).max(0);
return false;
}
self.inside = false;
if !allowed {
return false;
}
let time = self.time;
self.time += 1;
time >= transition_time
}
}
/// An entity's `portalCooldown` and `portalProcess`.
#[derive(Clone, Copy, Debug, Default)]
pub struct PortalState {
pub cooldown: i32,
pub process: Option<Process>,
}
impl PortalState {
/// `Entity.setAsInsidePortal` for a nether portal block at `pos`.
pub fn set_inside(&mut self, pos: BlockPos, delay: i32) {
if self.cooldown > 0 {
self.cooldown = delay;
return;
}
match &mut self.process {
None => {
self.process = Some(Process {
entry: pos,
time: 0,
inside: true,
})
}
Some(p) if !p.inside => {
p.entry = pos;
p.inside = true;
}
Some(_) => {}
}
}
/// `Entity.handlePortal`: the entry block when the entity goes through
/// (its cooldown then set to `delay`).
pub fn handle(&mut self, allowed: bool, transition_time: i32, delay: i32) -> Option<BlockPos> {
// processPortalCooldown
if self.cooldown > 0 {
self.cooldown -= 1;
}
let process = self.process.as_mut()?;
if process.process(allowed, transition_time) {
self.cooldown = delay;
return Some(process.entry);
}
// hasExpired
if process.time <= 0 {
self.process = None;
}
None
}
}
@@ -0,0 +1,272 @@
//! Rust side of tools/test_nether_portal_parity.py: replays
//! `VanillaPortalOracle` cases (an entity in a nether portal, the destination
//! level's terrain and portals) through `horizon_world::level::portal_travel`
//! and prints the same result text.
use horizon_core::{
geometry::{Axis, Vec3},
position::BlockPos,
random::LegacyRandom,
};
use horizon_world::{
level::{
Behaviours, Dimension, LevelAccess, Ticks,
data::load_registry,
portal_travel::{
BorderBounds, closest_portal, collision_free_position, exit_position,
largest_rectangle_around, relative_position,
},
},
registry::BlockStateId,
};
use serde_json::Value;
use std::{
collections::HashMap,
io::{BufRead, Write},
path::Path,
};
struct Cells {
cells: HashMap<BlockPos, BlockStateId>,
air: BlockStateId,
random: LegacyRandom,
nether: bool,
}
impl LevelAccess for Cells {
fn block_state(&self, pos: BlockPos) -> BlockStateId {
self.cells.get(&pos).copied().unwrap_or(self.air)
}
fn set_raw(&mut self, pos: BlockPos, state: BlockStateId) -> Option<BlockStateId> {
let old = self.block_state(pos);
if state == self.air {
self.cells.remove(&pos);
} else {
self.cells.insert(pos, state);
}
Some(old)
}
fn is_loaded(&self, _pos: BlockPos) -> bool {
true
}
fn min_y(&self) -> i32 {
if self.nether { 0 } else { -64 }
}
fn max_y(&self) -> i32 {
if self.nether { 256 } else { 320 }
}
fn random(&mut self) -> &mut LegacyRandom {
&mut self.random
}
fn game_time(&self) -> i64 {
0
}
fn dimension(&self) -> Dimension {
if self.nether {
Dimension::Nether
} else {
Dimension::Overworld
}
}
}
fn pos(v: &Value) -> BlockPos {
BlockPos::new(
v[0].as_i64().unwrap() as i32,
v[1].as_i64().unwrap() as i32,
v[2].as_i64().unwrap() as i32,
)
}
fn level(case: &Value, key: &str, air: BlockStateId, nether: bool) -> Cells {
let mut cells = HashMap::new();
for c in case[key].as_array().unwrap() {
let state = BlockStateId(c[3].as_i64().unwrap() as u32);
if state != air {
cells.insert(pos(c), state);
}
}
Cells {
cells,
air,
random: LegacyRandom::new(case["seed"].as_i64().unwrap()),
nether,
}
}
fn run(case: &Value, b: &Behaviours, air: BlockStateId, out: &mut Vec<String>) {
let from_nether = case["from"] == "nether";
let source = level(case, "source", air, from_nether);
let mut target = level(case, "target", air, !from_nether);
let dims = &case["entity"]["dims"];
let (width, height) = (
dims[0].as_f64().unwrap() as f32,
dims[1].as_f64().unwrap() as f32,
);
out.push(format!(
"dims {:08x} {:08x}",
width.to_bits(),
height.to_bits()
));
// Exact doubles, as bits.
let e = &case["entity"]["bits"];
let bit = |i: usize| f64::from_bits(u64::from_str_radix(e[i].as_str().unwrap(), 16).unwrap());
let at = Vec3::new(bit(0), bit(1), bit(2));
// WorldBorder: centre and size, the extent clamped to +-29999984.
let border = &case["border"];
let (cx, cz, size) = (
border["x"].as_f64().unwrap(),
border["z"].as_f64().unwrap(),
border["size"].as_f64().unwrap(),
);
let limit = 29_999_984.0;
let clamp = |v: f64| v.clamp(-limit, limit);
let bounds = BorderBounds {
min_x: clamp(cx - size / 2.0),
min_z: clamp(cz - size / 2.0),
max_x: clamp(cx + size / 2.0),
max_z: clamp(cz + size / 2.0),
};
// NetherPortalBlock.getDimensionTransitionFromExit: where in its portal
// the entity stands.
let entry = pos(&case["entry"]);
let entry_state = source.block_state(entry);
let (entry_x_axis, offset) = match b.portal_axis(entry_state) {
Some(x_axis) => {
let rectangle = largest_rectangle_around(
entry,
if x_axis { Axis::X } else { Axis::Z },
21,
Axis::Y,
21,
|p| source.block_state(p) == entry_state,
);
let m = rectangle.min_corner;
out.push(format!(
"entry {},{},{} {}x{}",
m.x, m.y, m.z, rectangle.axis1_size, rectangle.axis2_size
));
let mut offset = relative_position(rectangle, x_axis, at, width, height);
// LivingEntity, AbstractMinecart and AbstractBoat:
// resetForwardDirectionOfRelativePortalPosition.
if case["entity"]["reset_forward"].as_bool().unwrap_or(false) {
offset.z = 0.0;
}
out.push(format!(
"offset {:016x} {:016x} {:016x}",
offset.x.to_bits(),
offset.y.to_bits(),
offset.z.to_bits()
));
(x_axis, offset)
}
None => (true, Vec3::new(0.5, 0.0, 0.0)),
};
// NetherPortalBlock.getPortalDestination.
let scale = if from_nether { 8.0 } else { 1.0 / 8.0 };
let approximate = bounds.clamp(at.x * scale, at.y, at.z * scale);
let portals: Vec<BlockPos> = case["pois"].as_array().unwrap().iter().map(pos).collect();
let (min_section, max_section) = if from_nether { (-4, 19) } else { (0, 15) };
let mut ticks = Ticks::new(0);
out.push(format!(
"approximate {},{},{}",
approximate.x, approximate.y, approximate.z
));
let found = closest_portal(
&portals,
approximate,
!from_nether,
&bounds,
min_section,
max_section,
);
out.push(match found {
Some(p) => format!("found {},{},{}", p.x, p.y, p.z),
None => "found none".into(),
});
let exit = match found {
Some(found) => {
let state = target.block_state(found);
let x_axis = b.portal_axis(state).unwrap_or(true);
Some(largest_rectangle_around(
found,
if x_axis { Axis::X } else { Axis::Z },
21,
Axis::Y,
21,
|p| target.block_state(p) == state,
))
}
None => {
let logical = if from_nether { 384 } else { 128 };
b.create_portal(
&mut target,
&mut ticks,
approximate,
entry_x_axis,
&bounds,
logical,
)
}
};
let mut changed: Vec<BlockPos> = target
.cells
.keys()
.copied()
.chain(
level(case, "target", air, !from_nether)
.cells
.keys()
.copied(),
)
.collect();
changed.sort_by_key(|p| (p.x, p.y, p.z));
changed.dedup();
let before = level(case, "target", air, !from_nether);
for p in changed {
let now = target.block_state(p);
if before.block_state(p) != now {
out.push(format!("set {},{},{} {}", p.x, p.y, p.z, now.0));
}
}
let Some(exit) = exit else {
out.push("dest none".into());
return;
};
let exit_x_axis = b
.portal_axis(target.block_state(exit.min_corner))
.unwrap_or(true);
let (bottom, rotation) = exit_position(exit, exit_x_axis, entry_x_axis, offset, width, height);
let free = collision_free_position(bottom, width, height, &bounds, |p| {
b.collision_shape(target.block_state(p))
.map(|s| s.moved(Vec3::new(f64::from(p.x), f64::from(p.y), f64::from(p.z))))
});
out.push(format!(
"dest {:016x} {:016x} {:016x} {rotation:?}",
free.x.to_bits(),
free.y.to_bits(),
free.z.to_bits()
));
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut args = std::env::args().skip(1);
let resources = args.next().expect("resource directory");
let cases = args.next().expect("case file");
let output = args.next().expect("output file");
let resources = Path::new(&resources);
let registry = load_registry(resources)?;
let behaviours = Behaviours::load(&registry, resources)?;
let air = registry.default_state("minecraft:air").unwrap();
let mut out = std::io::BufWriter::new(std::fs::File::create(output)?);
for (index, line) in std::io::BufReader::new(std::fs::File::open(cases)?)
.lines()
.enumerate()
{
let case: Value = serde_json::from_str(&line?)?;
let mut lines = Vec::new();
run(&case, &behaviours, air, &mut lines);
writeln!(out, "case {index}")?;
for l in lines {
writeln!(out, "{l}")?;
}
}
Ok(())
}
+1
View File
@@ -112,6 +112,7 @@ mod interact;
pub mod pistons;
mod place;
mod portal;
pub mod portal_travel;
mod query;
mod rails;
mod redstone;
@@ -0,0 +1,628 @@
//! Nether portal travel: `PortalForcer` (finding and building exit portals),
//! `BlockUtil.getLargestRectangleAround`, `PortalShape.getRelativePosition`
//! and `NetherPortalBlock.createDimensionTransition`.
use super::{Behaviours, LevelAccess, Sim, Ticks};
use crate::fluid::FluidKind;
use crate::{
java_hash_map::{JavaHashMap, JavaKey},
registry::BlockStateId,
};
use horizon_core::{
geometry::{Aabb, Axis, Direction, ShapeOp, Vec3, VoxelShape},
position::BlockPos,
};
use std::cmp::Ordering;
/// `BlockUtil.FoundRectangle`: the low corner and the sizes along the two axes.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct FoundRectangle {
pub min_corner: BlockPos,
pub axis1_size: i32,
pub axis2_size: i32,
}
/// The world border's extent (`getMinX` .. `getMaxX`, `getMinZ` .. `getMaxZ`).
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct BorderBounds {
pub min_x: f64,
pub min_z: f64,
pub max_x: f64,
pub max_z: f64,
}
impl BorderBounds {
/// `WorldBorder.isWithinBounds(x, z)`.
pub fn contains(&self, x: f64, z: f64) -> bool {
x >= self.min_x && x < self.max_x && z >= self.min_z && z < self.max_z
}
/// `WorldBorder.isWithinBounds(BlockPos)`.
pub fn contains_block(&self, pos: BlockPos) -> bool {
self.contains(f64::from(pos.x), f64::from(pos.z))
}
/// `WorldBorder.clampToBounds(x, y, z)`.
pub fn clamp(&self, x: f64, y: f64, z: f64) -> BlockPos {
let margin = f64::from(1.0e-5_f32);
let clamp = |v: f64, lo: f64, hi: f64| if v < lo { lo } else { v.min(hi) };
BlockPos::new(
clamp(x, self.min_x, self.max_x - margin).floor() as i32,
y.floor() as i32,
clamp(z, self.min_z, self.max_z - margin).floor() as i32,
)
}
}
fn step(pos: BlockPos, direction: Direction, n: i32) -> BlockPos {
let [dx, dy, dz] = direction.normal();
pos.offset(dx * n, dy * n, dz * n)
}
fn negative(axis: Axis) -> Direction {
match axis {
Axis::X => Direction::West,
Axis::Y => Direction::Down,
Axis::Z => Direction::North,
}
}
fn component(pos: BlockPos, axis: Axis) -> i32 {
match axis {
Axis::X => pos.x,
Axis::Y => pos.y,
Axis::Z => pos.z,
}
}
/// `Direction.getClockWise` for the horizontal directions.
fn clockwise(direction: Direction) -> Direction {
match direction {
Direction::North => Direction::East,
Direction::East => Direction::South,
Direction::South => Direction::West,
Direction::West => Direction::North,
other => other,
}
}
/// `BlockUtil.getLimit`: how many steps from `start` along `direction` pass `test`.
fn limit(
test: &mut impl FnMut(BlockPos) -> bool,
start: BlockPos,
direction: Direction,
limit: i32,
) -> i32 {
let mut max = 0;
let mut pos = start;
while max < limit {
pos = step(pos, direction, 1);
if !test(pos) {
break;
}
max += 1;
}
max
}
/// `BlockUtil.getMaxRectangleLocation`: the widest-area run of `columns`
/// (start, end inclusive) and its height.
fn max_rectangle_location(columns: &[i32]) -> (i32, i32, i32) {
let (mut max_start, mut max_end, mut max_height) = (0usize, 0usize, 0i32);
let mut stack: Vec<usize> = vec![0];
for column in 1..=columns.len() {
let height = if column == columns.len() {
0
} else {
columns[column]
};
while let Some(&top) = stack.last() {
let stack_height = columns[top];
if height >= stack_height {
stack.push(column);
break;
}
stack.pop();
let start = stack.last().map_or(0, |t| t + 1);
if i64::from(stack_height) * (column - start) as i64
> i64::from(max_height) * (max_end - max_start) as i64
{
max_end = column;
max_start = start;
max_height = stack_height;
}
}
if stack.is_empty() {
stack.push(column);
}
}
(max_start as i32, max_end as i32 - 1, max_height)
}
/// `BlockUtil.getLargestRectangleAround`: the largest rectangle of positions
/// passing `test` in the plane of `axis1` and `axis2` that contains `center`.
pub fn largest_rectangle_around(
center: BlockPos,
axis1: Axis,
limit1: i32,
axis2: Axis,
limit2: i32,
mut test: impl FnMut(BlockPos) -> bool,
) -> FoundRectangle {
let negative1 = negative(axis1);
let positive1 = negative1.opposite();
let negative2 = negative(axis2);
let positive2 = negative2.opposite();
let negative_delta1 = limit(&mut test, center, negative1, limit1);
let positive_delta1 = limit(&mut test, center, positive1, limit1);
let center_index1 = negative_delta1 as usize;
let mut bounds = vec![(0, 0); center_index1 + 1 + positive_delta1 as usize];
bounds[center_index1] = (
limit(&mut test, center, negative2, limit2),
limit(&mut test, center, positive2, limit2),
);
let center_index2 = bounds[center_index1].0;
for i in 1..=negative_delta1 as usize {
let last = bounds[center_index1 - (i - 1)];
let at = step(center, negative1, i as i32);
bounds[center_index1 - i] = (
limit(&mut test, at, negative2, last.0),
limit(&mut test, at, positive2, last.1),
);
}
for i in 1..=positive_delta1 as usize {
let last = bounds[center_index1 + i - 1];
let at = step(center, positive1, i as i32);
bounds[center_index1 + i] = (
limit(&mut test, at, negative2, last.0),
limit(&mut test, at, positive2, last.1),
);
}
let (mut min_axis1, mut min_axis2, mut size_axis1, mut size_axis2) = (0, 0, 0, 0);
let mut columns = vec![0; bounds.len()];
for i2 in (0..=center_index2).rev() {
for (i1, b) in bounds.iter().enumerate() {
let min2 = center_index2 - b.0;
let max2 = center_index2 + b.1;
columns[i1] = if i2 >= min2 && i2 <= max2 {
max2 + 1 - i2
} else {
0
};
}
let (start, end, height) = max_rectangle_location(&columns);
let new_size1 = 1 + end - start;
if new_size1 * height > size_axis1 * size_axis2 {
min_axis1 = start;
min_axis2 = i2;
size_axis1 = new_size1;
size_axis2 = height;
}
}
let corner = step(
center,
negative1.opposite(),
min_axis1 - center_index1 as i32,
);
let corner = step(corner, negative2.opposite(), min_axis2 - center_index2);
FoundRectangle {
min_corner: corner,
axis1_size: size_axis1,
axis2_size: size_axis2,
}
}
/// `PortalShape.getRelativePosition`: where in the portal rectangle an entity
/// of `width` by `height` at `position` stands (right and up as fractions,
/// forward in blocks; living entities, minecarts and boats then drop the
/// forward part, `LivingEntity.resetForwardDirectionOfRelativePortalPosition`).
pub fn relative_position(
rectangle: FoundRectangle,
x_axis: bool,
position: Vec3,
width: f32,
height: f32,
) -> Vec3 {
let axis = if x_axis { Axis::X } else { Axis::Z };
let room_width = f64::from(rectangle.axis1_size) - f64::from(width);
let room_height = f64::from(rectangle.axis2_size) - f64::from(height);
let bottom = rectangle.min_corner;
let clamp = |v: f64| if v < 0.0 { 0.0 } else { v.min(1.0) };
let right = if room_width > 0.0 {
let start = f64::from(component(bottom, axis)) + f64::from(width) / 2.0;
clamp((position.component(axis) - start) / room_width)
} else {
0.5
};
let up = if room_height > 0.0 {
clamp((position.y - f64::from(bottom.y)) / room_height)
} else {
0.0
};
let forward_axis = if x_axis { Axis::Z } else { Axis::X };
let forward =
position.component(forward_axis) - (f64::from(component(bottom, forward_axis)) + 0.5);
Vec3::new(right, up, forward)
}
/// `NetherPortalBlock.createDimensionTransition` before
/// `PortalShape.findCollisionFreePosition`: the bottom centre of the entity in
/// the exit portal and the yaw it turns by (0 or 90).
pub fn exit_position(
exit: FoundRectangle,
exit_x_axis: bool,
entry_x_axis: bool,
offset: Vec3,
width: f32,
height: f32,
) -> (Vec3, f32) {
let rotation = if entry_x_axis == exit_x_axis {
0.0
} else {
90.0
};
let right = f64::from(width) / 2.0 + (f64::from(exit.axis1_size) - f64::from(width)) * offset.x;
let up = (f64::from(exit.axis2_size) - f64::from(height)) * offset.y;
let forward = 0.5 + offset.z;
let b = exit.min_corner;
let target = Vec3::new(
f64::from(b.x) + if exit_x_axis { right } else { forward },
f64::from(b.y) + up,
f64::from(b.z) + if exit_x_axis { forward } else { right },
);
(target, rotation)
}
impl BorderBounds {
/// `WorldBorder.isWithinBounds(AABB)`: both corners, the far one pulled
/// in by 1.0E-5F.
pub fn contains_box(&self, b: Aabb) -> bool {
let margin = f64::from(1.0e-5_f32);
self.contains(b.min(Axis::X), b.min(Axis::Z))
&& self.contains(b.max(Axis::X) - margin, b.max(Axis::Z) - margin)
}
}
/// `CollisionGetter.findFreePosition` without an entity's collision context:
/// within `allowed`, the point nearest `preferred` where a box of the size
/// centred there meets no block collision inside the border. `shape(pos)`
/// is the block's collision shape there, in world coordinates.
pub fn find_free_position(
allowed: Aabb,
preferred: Vec3,
size: Vec3,
border: &BorderBounds,
mut shape: impl FnMut(BlockPos) -> Option<VoxelShape>,
) -> Option<Vec3> {
let allowed_shape = VoxelShape::from_box(allowed).ok()?;
if allowed_shape.is_empty() {
return None;
}
let search = allowed_shape.bounds()?.inflate(size);
let half = size.scale(0.5);
let mut expanded = VoxelShape::empty();
// BlockCollisions over the search area: every block whose shape meets it.
let lo = |v: f64| (v - 1.0e-7).floor() as i32 - 1;
let hi = |v: f64| (v + 1.0e-7).floor() as i32 + 1;
for z in lo(search.min(Axis::Z))..=hi(search.max(Axis::Z)) {
for y in lo(search.min(Axis::Y))..=hi(search.max(Axis::Y)) {
for x in lo(search.min(Axis::X))..=hi(search.max(Axis::X)) {
let Some(block) = shape(BlockPos::new(x, y, z)) else {
continue;
};
if block.is_empty()
|| !block.boxes().iter().any(|b| b.intersects(search))
|| !block.bounds().is_some_and(|b| border.contains_box(b))
{
continue;
}
for b in block.boxes() {
let grown = VoxelShape::from_box(b.inflate(half)).ok()?;
expanded = expanded.join(&grown, ShapeOp::OR).ok()?;
}
}
}
}
let free = allowed_shape.join(&expanded, ShapeOp::ONLY_FIRST).ok()?;
free.closest_point(preferred)
}
/// `PortalShape.findCollisionFreePosition`: `bottom_center` moved to the
/// nearest spot within its column of the entity's width (and a block up)
/// where it fits; entities over 4 blocks stay put.
pub fn collision_free_position(
bottom_center: Vec3,
width: f32,
height: f32,
border: &BorderBounds,
shape: impl FnMut(BlockPos) -> Option<VoxelShape>,
) -> Vec3 {
if width > 4.0 || height > 4.0 {
return bottom_center;
}
let half_height = f64::from(height) / 2.0;
let center = bottom_center.add_vector(Vec3::new(0.0, half_height, 0.0));
let w = f64::from(width);
let allowed = Aabb::of_size(center, Vec3::new(w, 0.0, w))
.expand_towards(Vec3::new(0.0, 1.0, 0.0))
.inflate(Vec3::new(1.0e-6, 1.0e-6, 1.0e-6));
find_free_position(
allowed,
center,
Vec3::new(w, f64::from(height), w),
border,
shape,
)
.map_or(bottom_center, |p| {
p.subtract(Vec3::new(0.0, half_height, 0.0))
})
}
/// A portal block position as a `PoiRecord` in a `PoiSection`'s hash set.
#[derive(Clone, Copy, PartialEq, Eq)]
struct Record(BlockPos);
impl JavaKey for Record {
/// `Vec3i.hashCode`.
fn java_hash(&self) -> i32 {
let p = self.0;
p.y.wrapping_add(p.z.wrapping_mul(31))
.wrapping_mul(31)
.wrapping_add(p.x)
}
fn tie_break(&self, other: &Self) -> Ordering {
(self.0.y, self.0.z, self.0.x)
.cmp(&(other.0.y, other.0.z, other.0.x))
.then(Ordering::Less)
}
}
/// `PortalForcer.findClosestPortalPosition` over the nether portal blocks
/// `portals` (the points of interest, in the order their sections hold
/// them): within 16 blocks of `approximate` going to the Nether, 128 out of
/// it, inside the border, nearest first, then lowest.
pub fn closest_portal(
portals: &[BlockPos],
approximate: BlockPos,
to_nether: bool,
border: &BorderBounds,
min_section: i32,
max_section: i32,
) -> Option<BlockPos> {
let radius: i32 = if to_nether { 16 } else { 128 };
// PoiManager.getInSquare: the chunks of ChunkPos.rangeClosed (x fastest),
// each section from the bottom, each section's records in hash set order.
let chunk_radius = radius.div_euclid(16) + 1;
let (cx, cz) = (approximate.x >> 4, approximate.z >> 4);
let mut sections: std::collections::HashMap<(i32, i32, i32), JavaHashMap<Record, ()>> =
std::collections::HashMap::new();
for &p in portals {
sections
.entry((p.x >> 4, p.y >> 4, p.z >> 4))
.or_default()
.put(Record(p), ());
}
let mut best: Option<(f64, BlockPos)> = None;
for z in cz - chunk_radius..=cz + chunk_radius {
for x in cx - chunk_radius..=cx + chunk_radius {
for y in min_section..=max_section {
let Some(set) = sections.get(&(x, y, z)) else {
continue;
};
for (record, _) in set.entries() {
let p = record.0;
if (p.x - approximate.x).abs() > radius
|| (p.z - approximate.z).abs() > radius
|| !border.contains_block(p)
{
continue;
}
let (dx, dy, dz) = (
f64::from(p.x) - f64::from(approximate.x),
f64::from(p.y) - f64::from(approximate.y),
f64::from(p.z) - f64::from(approximate.z),
);
let d = dx * dx + dy * dy + dz * dz;
if best.is_none_or(|(bd, bp)| d < bd || (d == bd && p.y < bp.y)) {
best = Some((d, p));
}
}
}
}
}
best.map(|(_, p)| p)
}
/// `BlockPos.spiralAround(center, radius, first, second)`.
fn spiral_around(
center: BlockPos,
radius: i32,
first: Direction,
second: Direction,
) -> Vec<BlockPos> {
let directions = [first, second, first.opposite(), second.opposite()];
let mut out = Vec::new();
let mut last = step(center, second, 1);
let legs = 4 * radius;
let (mut leg, mut leg_size, mut leg_index) = (-1i32, 0, 0);
loop {
let cursor = step(last, directions[((leg + 4) % 4) as usize], 1);
last = cursor;
if leg_index >= leg_size {
if leg >= legs {
return out;
}
leg += 1;
leg_index = 0;
leg_size = leg / 2 + 1;
}
leg_index += 1;
out.push(cursor);
}
}
impl<L: LevelAccess + ?Sized> Sim<'_, L> {
/// `PortalForcer.canPortalReplaceBlock`.
fn portal_can_replace(&self, pos: BlockPos) -> bool {
let state = self.state(pos);
self.b.is_replaceable(state) && self.b.fluid(state).kind() == FluidKind::Empty
}
/// `PortalForcer.canHostFrame`.
fn can_host_frame(&self, origin: BlockPos, direction: Direction, offset: i32) -> bool {
let side = clockwise(direction);
for width in -1..3 {
for height in -1..4 {
let at = step(step(origin, direction, width), side, offset).offset(0, height, 0);
if height < 0 && !self.b.is_solid(self.state(at)) {
return false;
}
if height >= 0 && !self.portal_can_replace(at) {
return false;
}
}
}
true
}
/// `PortalForcer.createPortal`: a 2 by 3 portal in an obsidian frame at the
/// nearest column around `origin` with room for it (on a platform it
/// carves out when none has), facing `x_axis`.
pub fn create_portal(
&mut self,
origin: BlockPos,
x_axis: bool,
border: &BorderBounds,
logical_height: i32,
) -> Option<FoundRectangle> {
let direction = if x_axis {
Direction::East
} else {
Direction::South
};
let (min_y, max_y) = (self.level.min_y(), self.level.max_y() - 1);
let max_placeable = max_y.min(min_y + logical_height - 1);
let distance = |a: BlockPos, b: BlockPos| {
let (dx, dy, dz) = (
f64::from(a.x) - f64::from(b.x),
f64::from(a.y) - f64::from(b.y),
f64::from(a.z) - f64::from(b.z),
);
dx * dx + dy * dy + dz * dz
};
let mut full: Option<(f64, BlockPos)> = None;
let mut partial: Option<(f64, BlockPos)> = None;
for column in spiral_around(origin, 16, Direction::East, Direction::South) {
let top = self.b.motion_blocking_top(&*self.level, column).y;
let height = max_placeable.min(top);
if !border.contains_block(column) || !border.contains_block(step(column, direction, 1))
{
continue;
}
let mut y = height;
while y >= min_y {
let at = BlockPos::new(column.x, y, column.z);
if self.portal_can_replace(at) {
let first_empty = y;
while y > min_y
&& self.portal_can_replace(BlockPos::new(column.x, y - 1, column.z))
{
y -= 1;
}
if y + 4 <= max_placeable {
let delta = first_empty - y;
if delta <= 0 || delta >= 3 {
let at = BlockPos::new(column.x, y, column.z);
if self.can_host_frame(at, direction, 0) {
let d = distance(origin, at);
if self.can_host_frame(at, direction, -1)
&& self.can_host_frame(at, direction, 1)
&& full.is_none_or(|(fd, _)| fd > d)
{
full = Some((d, at));
}
if full.is_none() && partial.is_none_or(|(pd, _)| pd > d) {
partial = Some((d, at));
}
}
}
}
}
y -= 1;
}
}
let b = self.b;
let obsidian = b.default_of(b.named.obsidian);
let spot = match full.or(partial) {
Some((_, spot)) => spot,
None => {
let min_start = (min_y + 1).max(70);
let max_start = max_placeable - 9;
if max_start < min_start {
return None;
}
let [sx, _, sz] = direction.normal();
let y = origin.y.clamp(min_start, max_start);
let spot = border.clamp(
f64::from(origin.x - sx),
f64::from(y),
f64::from(origin.z - sz),
);
let side = clockwise(direction);
let air = b.default_of(b.named.air);
for side_offset in -1..2 {
for width in 0..2 {
for height in -1..3 {
let at = step(step(spot, direction, width), side, side_offset)
.offset(0, height, 0);
self.set_block(at, if height < 0 { obsidian } else { air }, 3);
}
}
}
spot
}
};
for width in -1..3 {
for height in -1..4 {
if width == -1 || width == 2 || height == -1 || height == 3 {
self.set_block(
step(spot, direction, width).offset(0, height, 0),
obsidian,
3,
);
}
}
}
let base = b.default_of(b.named.nether_portal);
let portal = b
.table
.with_text(base, b.props.axis, if x_axis { "x" } else { "z" })
.unwrap_or(base);
for width in 0..2 {
for height in 0..3 {
self.set_block(
step(spot, direction, width).offset(0, height, 0),
portal,
18,
);
}
}
Some(FoundRectangle {
min_corner: spot,
axis1_size: 2,
axis2_size: 3,
})
}
}
impl Behaviours {
/// `PortalForcer.createPortal` on `level` (see `Sim::create_portal`).
pub fn create_portal<L: LevelAccess + ?Sized>(
&self,
level: &mut L,
ticks: &mut Ticks,
origin: BlockPos,
x_axis: bool,
border: &BorderBounds,
logical_height: i32,
) -> Option<FoundRectangle> {
self.sim(level, ticks)
.create_portal(origin, x_axis, border, logical_height)
}
/// The axis of a nether portal state: Some(true) for X, Some(false) for
/// Z, None for other blocks.
pub fn portal_axis(&self, state: BlockStateId) -> Option<bool> {
self.is_block(state, self.named.nether_portal)
.then(|| self.table.text(state, self.props.axis) == "x")
}
}
@@ -71,6 +71,7 @@ public final class VanillaBlockUpdateOracle {
if (old == state) {
return null;
}
world.columns = null;
if (state == AIR) {
world.cells.remove(pos);
} else {
@@ -189,8 +190,29 @@ public final class VanillaBlockUpdateOracle {
@Override public boolean hasChunk(int x, int z) { return true; }
@Override public boolean isClientSide() { return false; }
@Override public RandomSource getRandom() { return rng; }
@Override public int getMinY() { return -64; }
@Override public int getHeight() { return 384; }
// Another dimension, border and points of interest (the portal oracle);
// the overworld and an unbounded border when unset.
net.minecraft.world.level.dimension.DimensionType type;
net.minecraft.resources.ResourceKey<net.minecraft.world.level.Level> dimensionKey;
net.minecraft.world.level.border.WorldBorder border;
net.minecraft.world.entity.ai.village.poi.PoiManager poi;
@Override public int getMinY() { return type == null ? -64 : type.minY(); }
@Override public int getHeight() { return type == null ? 384 : type.height(); }
@Override public net.minecraft.world.entity.ai.village.poi.PoiManager getPoiManager() { return poi != null ? poi : super.getPoiManager(); }
/** Level.getHeight from the cells (only for another dimension's level). */
Map<Long, List<BlockPos>> columns;
@Override public int getHeight(net.minecraft.world.level.levelgen.Heightmap.Types kind, int x, int z) {
if (type == null) return super.getHeight(kind, x, z);
if (columns == null) {
columns = new HashMap<>();
for (BlockPos c : cells.keySet()) columns.computeIfAbsent(BlockPos.asLong(c.getX(), 0, c.getZ()), k -> new ArrayList<>()).add(c);
}
int top = getMinY() - 1;
for (BlockPos c : columns.getOrDefault(BlockPos.asLong(x, 0, z), List.of())) {
if (c.getY() > top && kind.isOpaque().test(getBlockState(c))) top = c.getY();
}
return top + 1;
}
@Override public long getGameTime() { return time; }
@Override public long nextSubTickCount() { return subTick++; }
@Override public LevelTicks<Block> getBlockTicks() { return blockTicks; }
@@ -202,7 +224,7 @@ public final class VanillaBlockUpdateOracle {
@Override public GameRules getGameRules() { return rules; }
@Override public net.minecraft.server.MinecraftServer getServer() { return server; }
@Override public net.minecraft.world.item.crafting.RecipeManager recipeAccess() { return Server.recipes; }
@Override public net.minecraft.world.level.border.WorldBorder getWorldBorder() { return new net.minecraft.world.level.border.WorldBorder(); }
@Override public net.minecraft.world.level.border.WorldBorder getWorldBorder() { return border != null ? border : new net.minecraft.world.level.border.WorldBorder(); }
@Override public int getSeaLevel() { return 63; }
@Override public int getBrightness(net.minecraft.world.level.LightLayer layer, BlockPos p) { return layer == net.minecraft.world.level.LightLayer.SKY ? skyLight : blockLight; }
@Override public int getRawBrightness(BlockPos p, int darkening) { return Math.max(skyLight - darkening, blockLight); }
@@ -328,9 +350,9 @@ public final class VanillaBlockUpdateOracle {
}
return attributes;
}
@Override public net.minecraft.world.level.dimension.DimensionType dimensionType() { return OVERWORLD_TYPE; }
@Override public net.minecraft.world.level.dimension.DimensionType dimensionType() { return type != null ? type : OVERWORLD_TYPE; }
/** The overworld (fire in an obsidian frame lights a portal here). */
@Override public net.minecraft.resources.ResourceKey<net.minecraft.world.level.Level> dimension() { return net.minecraft.world.level.Level.OVERWORLD; }
@Override public net.minecraft.resources.ResourceKey<net.minecraft.world.level.Level> dimension() { return dimensionKey != null ? dimensionKey : net.minecraft.world.level.Level.OVERWORLD; }
@Override public long getOverworldClockTime() { return DAY.totalTicks(); }
@Override public float getMoonBrightness(BlockPos p) {
return net.minecraft.world.level.dimension.DimensionType.MOON_BRIGHTNESS_PER_PHASE[environmentAttributes().getValue(net.minecraft.world.attribute.EnvironmentAttributes.MOON_PHASE, p).index()];
@@ -408,6 +430,10 @@ public final class VanillaBlockUpdateOracle {
/** The overworld dimension type from the vanilla data pack (its infiniburn tag, attributes and timelines). */
static net.minecraft.world.level.dimension.DimensionType loadOverworld() {
return loadDimensionType(net.minecraft.world.level.dimension.BuiltinDimensionTypes.OVERWORLD);
}
static net.minecraft.world.level.dimension.DimensionType loadDimensionType(net.minecraft.resources.ResourceKey<net.minecraft.world.level.dimension.DimensionType> key) {
var repo = net.minecraft.server.packs.repository.ServerPacksSource.createVanillaTrustedRepository();
repo.reload();
repo.setSelected(List.of("vanilla"));
@@ -417,7 +443,7 @@ public final class VanillaBlockUpdateOracle {
var context = net.minecraft.tags.TagLoader.buildUpdatedLookups(layers.getAccessForLoading(net.minecraft.server.RegistryLayer.WORLD), staticTags);
var world = net.minecraft.resources.RegistryDataLoader.load(resources, context, net.minecraft.resources.RegistryDataLoader.WORLD_REGISTRIES, Runnable::run).join();
staticTags.forEach(net.minecraft.core.Registry.PendingTags::apply);
return world.lookupOrThrow(net.minecraft.core.registries.Registries.DIMENSION_TYPE).getOrThrow(net.minecraft.world.level.dimension.BuiltinDimensionTypes.OVERWORLD).value();
return world.lookupOrThrow(net.minecraft.core.registries.Registries.DIMENSION_TYPE).getOrThrow(key).value();
}
static final class Loot extends net.minecraft.server.ReloadableServerRegistries.Holder {
@@ -449,6 +475,9 @@ public final class VanillaBlockUpdateOracle {
@Override public net.minecraft.world.item.crafting.RecipeManager getRecipeManager() { return recipes; }
@Override public net.minecraft.server.ReloadableServerRegistries.Holder reloadableRegistries() { return loot; }
@Override protected boolean initServer() { return false; }
/** The levels by dimension (the portal oracle's two). */
Map<net.minecraft.resources.ResourceKey<net.minecraft.world.level.Level>, net.minecraft.server.level.ServerLevel> levels;
@Override public net.minecraft.server.level.ServerLevel getLevel(net.minecraft.resources.ResourceKey<net.minecraft.world.level.Level> key) { return levels == null ? null : levels.get(key); }
@Override public int getMaxPlayers() { return 0; }
@Override public net.minecraft.server.permissions.LevelBasedPermissionSet operatorUserPermissions() { return null; }
@Override public net.minecraft.server.permissions.PermissionSet getFunctionCompilationPermissions() { return null; }
@@ -0,0 +1,144 @@
package dev.horizonlab.parity;
import com.google.gson.*;
import java.io.PrintWriter;
import java.nio.file.*;
import java.util.*;
import net.minecraft.core.BlockPos;
import net.minecraft.core.SectionPos;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.resources.Identifier;
import net.minecraft.world.entity.Entity;
import net.minecraft.world.entity.EntitySpawnReason;
import net.minecraft.world.entity.ai.village.poi.PoiManager;
import net.minecraft.world.entity.ai.village.poi.PoiSection;
import net.minecraft.world.entity.ai.village.poi.PoiTypes;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.Blocks;
import net.minecraft.world.level.block.NetherPortalBlock;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.dimension.BuiltinDimensionTypes;
/**
* Nether portal travel, one entity per case: `NetherPortalBlock.getPortalDestination`
* for an entity standing in a portal of one headless level (the block update
* oracle's), going to another (the Nether from the overworld or back), whose
* points of interest are the case's portal blocks in the case's order. It runs
* `PortalForcer.findClosestPortalPosition` and, when nothing is found,
* `createPortal`, `BlockUtil.getLargestRectangleAround`,
* `PortalShape.getRelativePosition` and `findCollisionFreePosition`. Printed:
* the entity's size, the exit portal found (or "created"), the blocks the
* destination changed and the arrival position (bits) and yaw.
*/
public final class VanillaPortalOracle {
/** The points of interest of the destination: the case's portal blocks. */
static final class Poi extends PoiManager {
Map<Long, PoiSection> sections;
Poi() {
super(null, null, null, false, null, null, null);
}
@Override protected Optional<PoiSection> getOrLoad(long key) { return Optional.ofNullable(sections.get(key)); }
@Override public void ensureLoadedAndValid(net.minecraft.world.level.LevelReader reader, BlockPos center, int radius) { }
}
static net.minecraft.world.level.dimension.DimensionType OVERWORLD, NETHER;
public static void main(String[] args) throws Exception {
ParityData.init();
VanillaBlockUpdateOracle.AIR = Blocks.AIR.defaultBlockState();
VanillaLevelShapeOracle.bindFluidTags(Path.of(args[0]).resolve("data/minecraft/tags/fluid"));
OVERWORLD = VanillaBlockUpdateOracle.OVERWORLD_TYPE = VanillaBlockUpdateOracle.loadOverworld();
NETHER = VanillaBlockUpdateOracle.loadDimensionType(BuiltinDimensionTypes.NETHER);
var allocator = Class.forName("sun.misc.Unsafe");
var field = allocator.getDeclaredField("theUnsafe");
field.setAccessible(true);
VanillaBlockUpdateOracle.unsafe = field.get(null);
VanillaBlockUpdateOracle.allocate = allocator.getMethod("allocateInstance", Class.class);
try (var out = new PrintWriter(Files.newBufferedWriter(Path.of(args[2]))); var lines = Files.lines(Path.of(args[1]))) {
int index = 0;
for (var line : (Iterable<String>) lines::iterator) {
var f = JsonParser.parseString(line).getAsJsonObject();
out.print("case " + index++ + "\n");
try {
for (String s : run(f)) out.print(s + "\n");
} catch (Throwable e) {
Throwable c = e;
while (c.getCause() != null) c = c.getCause();
if (System.getenv("ORACLE_TRACE") != null) c.printStackTrace();
StackTraceElement[] st = c.getStackTrace();
out.print("error " + c.getClass().getSimpleName() + " " + (st.length > 0 ? st[0].toString() : "") + " " + c.getMessage() + "\n");
}
}
}
}
static VanillaBlockUpdateOracle.World level(JsonObject f, String cells, boolean nether) throws Exception {
var copy = new JsonObject();
copy.add("cells", f.get(cells));
copy.add("seed", f.get("seed"));
var w = VanillaBlockUpdateOracle.build(copy);
w.type = nether ? NETHER : OVERWORLD;
w.dimensionKey = nether ? Level.NETHER : Level.OVERWORLD;
return w;
}
static List<String> run(JsonObject f) throws Exception {
boolean fromNether = f.get("from").getAsString().equals("nether");
var source = level(f, "source", fromNether);
var target = level(f, "target", !fromNether);
var levels = new HashMap<net.minecraft.resources.ResourceKey<Level>, net.minecraft.server.level.ServerLevel>();
levels.put(source.dimension(), source);
levels.put(target.dimension(), target);
source.server.levels = levels;
target.server = source.server;
var border = new net.minecraft.world.level.border.WorldBorder();
var b = f.getAsJsonObject("border");
border.setCenter(b.get("x").getAsDouble(), b.get("z").getAsDouble());
border.setSize(b.get("size").getAsDouble());
target.border = border;
var poi = (Poi) VanillaBlockUpdateOracle.allocate.invoke(VanillaBlockUpdateOracle.unsafe, Poi.class);
poi.sections = new HashMap<>();
VanillaBlockUpdateOracle.set(net.minecraft.world.level.chunk.storage.SectionStorage.class, poi, "levelHeightAccessor", target);
var portalType = BuiltInRegistries.POINT_OF_INTEREST_TYPE.getOrThrow(PoiTypes.NETHER_PORTAL);
for (var p : f.getAsJsonArray("pois")) {
BlockPos at = VanillaBlockUpdateOracle.readPos(p.getAsJsonArray());
poi.sections.computeIfAbsent(SectionPos.asLong(at), k -> new PoiSection(() -> { })).add(at, portalType);
}
target.poi = poi;
VanillaBlockUpdateOracle.set(net.minecraft.server.level.ServerLevel.class, target, "portalForcer", new net.minecraft.world.level.portal.PortalForcer(target));
var e = f.getAsJsonObject("entity");
Entity entity = BuiltInRegistries.ENTITY_TYPE.getValue(Identifier.parse(e.get("type").getAsString())).create(source, EntitySpawnReason.LOAD);
// Exact doubles, as bits.
var at = e.getAsJsonArray("bits");
java.util.function.IntToDoubleFunction bit = i -> Double.longBitsToDouble(Long.parseUnsignedLong(at.get(i).getAsString(), 16));
entity.setPos(bit.applyAsDouble(0), bit.applyAsDouble(1), bit.applyAsDouble(2));
List<String> out = new ArrayList<>();
var dimensions = entity.getDimensions(entity.getPose());
out.add(String.format("dims %08x %08x", Float.floatToIntBits(dimensions.width()), Float.floatToIntBits(dimensions.height())));
Map<BlockPos, BlockState> before = new HashMap<>(target.cells);
BlockPos entry = VanillaBlockUpdateOracle.readPos(f.getAsJsonArray("entry"));
// The steps getPortalDestination takes, for the report.
BlockState entryState = source.getBlockState(entry);
if (entryState.hasProperty(NetherPortalBlock.AXIS)) {
var axis = entryState.getValue(NetherPortalBlock.AXIS);
var area = net.minecraft.util.BlockUtil.getLargestRectangleAround(entry, axis, 21, net.minecraft.core.Direction.Axis.Y, 21, q -> source.getBlockState(q) == entryState);
out.add("entry " + VanillaBlockUpdateOracle.pos(area.minCorner) + " " + area.axis1Size + "x" + area.axis2Size);
var offset = entity.getRelativePortalPosition(axis, area);
out.add(String.format("offset %016x %016x %016x", Double.doubleToLongBits(offset.x), Double.doubleToLongBits(offset.y), Double.doubleToLongBits(offset.z)));
}
double scale = net.minecraft.world.level.dimension.DimensionType.getTeleportationScale(source.dimensionType(), target.dimensionType());
BlockPos approximate = border.clampToBounds(entity.getX() * scale, entity.getY(), entity.getZ() * scale);
out.add("approximate " + VanillaBlockUpdateOracle.pos(approximate));
out.add("found " + target.getPortalForcer().findClosestPortalPosition(approximate, !fromNether, border).map(VanillaBlockUpdateOracle::pos).orElse("none"));
var transition = ((NetherPortalBlock) Blocks.NETHER_PORTAL).getPortalDestination(source, entity, entry);
out.addAll(VanillaBlockUpdateOracle.summary(target, before));
if (transition == null) {
out.add("dest none");
} else {
var p = transition.position();
out.add(String.format("dest %016x %016x %016x %s", Double.doubleToLongBits(p.x), Double.doubleToLongBits(p.y), Double.doubleToLongBits(p.z),
Float.toString(transition.yRot())));
}
return out;
}
}
@@ -227,6 +227,21 @@ public final class VanillaSceneMotionOracle {
@Override public Vec3 getKnownMovement(){return tickStart==null?Vec3.ZERO:position().subtract(tickStart);}
@Override protected void applyInput(){if(!preparedInput)super.applyInput();}
void peaceful(){tickRegeneration();}
// Entity.handlePortal without the destination (none: one level here),
// remembering the entry of a portal it would go through.
String travel;
// The creative delay applies with invulnerable abilities, set only for
// the transition time (the scene's food code runs without abilities).
void portalTick(boolean creative){
processPortalCooldown();
if(portalProcess!=null){
var entry=portalProcess.getEntryPosition();
boolean was=getAbilities().invulnerable;getAbilities().invulnerable=creative;
boolean through;try{through=portalProcess.processPortalTeleportation((net.minecraft.server.level.ServerLevel)sceneLevel,this,canUsePortal(false));}finally{getAbilities().invulnerable=was;}
if(through){travel=entry.getX()+","+entry.getY()+","+entry.getZ();setPortalCooldown();}
else if(portalProcess.hasExpired())portalProcess=null;
}
}
void clock()throws Exception{sceneLevel.time++;tickCount++;if(cooldown.getInt(this)>0)cooldown.setInt(this,cooldown.getInt(this)-1);if(hurtTime>0)hurtTime--;}
void playerMovementTick(Vec3 input,boolean jumping){
preparedInput=true;xxa=(float)input.x;yya=0;zza=(float)input.z;setJumping(jumping);
@@ -257,6 +272,8 @@ public final class VanillaSceneMotionOracle {
p.onGround(),noBlocks.getBoolean(p),pos(support.get(p)),Double.doubleToLongBits(p.fallDistance),pos(last.get(p)),p.needsSync,p.syncPosition,Float.floatToIntBits(storedSpeed.getFloat(p)),delay.getInt(p),Float.floatToIntBits(p.yHeadRot),trigger.getInt(p),grace.getInt(p),impact.get(p)==null?"none":vectorBits((Vec3)impact.get(p)),String.join(";",attributes));
out.println("events "+String.join(" | ",p.events));p.events.clear();
out.println("block "+Block.getId(p.level().getBlockState(new BlockPos(25,3,25)))+" frozen "+p.frozen+" "+p.isInPowderSnow+" "+p.wasInPowderSnow+" "+vectorBits((Vec3)stuck.get(p)));
var pp=p.portalProcess;
out.println("portal "+p.getPortalCooldown()+" "+(pp==null?"none":pp.getEntryPosition().getX()+","+pp.getEntryPosition().getY()+","+pp.getEntryPosition().getZ()+" "+pp.getPortalTime()+" "+pp.isInsidePortalThisTick())+" "+(p.travel==null?"-":p.travel));p.travel=null;
out.printf("health %08x %08x %08x %d %d %08x %d %d %s %d %s %s %s %s %s %d%n",
Float.floatToIntBits(p.getHealth()),Float.floatToIntBits(p.getAbsorptionAmount()),Float.floatToIntBits(foodExhaustion.getFloat(p.getFoodData())),
noAction.getInt(p),cooldown.getInt(p),Float.floatToIntBits(lastHurt.getFloat(p)),p.hurtDuration,p.hurtTime,sourceName((DamageSource)lastDamage.get(p)),lastStamp.getLong(p),healthDead.getBoolean(p),p.syncVelocity,
@@ -373,6 +390,7 @@ public final class VanillaSceneMotionOracle {
((EntityEquipment)field(LivingEntity.class,"equipment").get(p)).set(net.minecraft.world.entity.EquipmentSlot.FEET,stack);
}
case "frozen"->p.frozen=op.get("value").getAsInt();
case "portal_tick"->p.portalTick(op.get("creative").getAsBoolean());
case "weaving"->p.weaving=op.get("value").getAsBoolean();
case "flying"->{var a=p.getAbilities();a.mayfly=a.flying=op.get("value").getAsBoolean();}
case "trigger"->trigger.setInt(p,op.get("value").getAsInt());
File diff suppressed because one or more lines are too long
+182
View File
@@ -0,0 +1,182 @@
#!/usr/bin/env python3
"""Compare where vanilla's nether portals send an entity with Horizon's.
Every case has an entity (an item, a mob, a minecart, an arrow) standing in a
nether portal of one level (the overworld or the Nether), a random destination
around the scaled position (terrain, water, lava, ceilings, other portals) and
a world border, sometimes tight enough to clamp the exit. Vanilla runs
`NetherPortalBlock.getPortalDestination` over two headless levels of the block
update oracle (`VanillaPortalOracle`): `PortalForcer.findClosestPortalPosition`
over the destination's portal points of interest, `createPortal` when there is
none, `BlockUtil.getLargestRectangleAround`, `PortalShape.getRelativePosition`
and `findCollisionFreePosition`. Horizon runs `horizon_world::level::portal_travel`
(`portal_travel_fixture`). Both print the entity's size, the blocks the
destination changed, and the arrival position (bits) and yaw.
"""
import json
import os
import random
import struct
try:
from . import block_update_harness as h, lab, test_dispenser_parity as d, test_rust_parity as base
except ImportError:
import block_update_harness as h
import lab
import test_dispenser_parity as d
import test_rust_parity as base
PARITY_RUST_SCOPE = ['crates/horizon-world/', 'crates/horizon-core/']
# EntityType dimensions (width, height) of the travellers.
ENTITIES = {'minecraft:item': (0.25, 0.25), 'minecraft:zombie': (0.6, 1.95), 'minecraft:skeleton': (0.6, 1.99),
'minecraft:creeper': (0.6, 1.7), 'minecraft:minecart': (0.98, 0.7), 'minecraft:arrow': (0.5, 0.5),
'minecraft:horse': (1.3964844, 1.6), 'minecraft:spider': (1.4, 0.9), 'minecraft:ghast': (4.0, 4.0),
'minecraft:oak_boat': (1.375, 0.5625)}
GROUND = ['stone', 'dirt', 'grass_block', 'netherrack', 'sand', 'gravel', 'oak_planks', 'soul_sand', 'blackstone']
DECOR = ['short_grass', 'snow', 'water', 'lava', 'oak_leaves', 'oak_fence', 'torch', 'glass', 'stone_slab', 'dead_bush']
def portal(states, cells, pois, corner, x_axis, width, height, frame=True):
"""Obsidian around a width by height portal whose bottom left is `corner`."""
x, y, z = corner
dx, dz = (1, 0) if x_axis else (0, 1)
state = states.get('nether_portal', axis='x' if x_axis else 'z')
for w in range(-1, width + 1):
for v in range(-1, height + 1):
at = [x + dx * w, y + v, z + dz * w]
if 0 <= w < width and 0 <= v < height:
cells[tuple(at)] = state
if pois is not None:
pois.append(at)
elif frame:
cells[tuple(at)] = states.get('obsidian')
def terrain(states, rng, cells, center, nether):
"""Columns around `center`: ground, holes, liquids, plants, a ceiling."""
cx, cy, cz = center
lo, hi = (1, 120) if nether else (-60, 300)
style = rng.choice(['flat', 'flat', 'hills', 'solid', 'empty', 'cave', 'sea'])
base = max(lo + 2, min(hi - 12, cy + rng.randint(-12, 12)))
span = rng.choice([8, 20, 24])
for x in range(cx - span, cx + span + 1):
for z in range(cz - span, cz + span + 1):
if style == 'empty':
continue
top = base + (rng.randint(-3, 3) if style == 'hills' else 0)
if style == 'solid':
for y in range(top - 6, top + 9):
cells[(x, y, z)] = states.get(rng.choice(GROUND))
continue
if rng.random() < 0.04:
continue
for y in range(top - 3, top + 1):
cells[(x, y, z)] = states.get(rng.choice(GROUND) if y < top else rng.choice(['grass_block', 'stone', 'netherrack']))
if style == 'sea':
for y in range(top + 1, top + 3):
cells[(x, y, z)] = states.get('water')
elif rng.random() < 0.08:
cells[(x, top + 1, z)] = states.get(rng.choice(DECOR))
if style == 'cave':
for y in range(top + 4, top + 7):
cells[(x, y, z)] = states.get('stone')
def cases(facts, count, seed):
rng = random.Random(seed)
states = d.States(facts)
for n in range(count):
from_nether = rng.random() < 0.5
x_axis = rng.random() < 0.5
width, height = rng.choice([2, 2, 3, 4]), rng.choice([3, 3, 4, 5])
spread = rng.choice([30, 300, 3000])
lo, hi = (5, 100) if from_nether else (-50, 250)
corner = (rng.randint(-spread, spread), rng.randint(lo, hi), rng.randint(-spread, spread))
source = {}
portal(states, source, None, corner, x_axis, width, height)
kind = rng.choice(sorted(ENTITIES))
dims = ENTITIES[kind]
dx, dz = (1, 0) if x_axis else (0, 1)
along = rng.uniform(0, width)
up = rng.uniform(0, height - 0.1)
across = rng.uniform(0.1, 0.9)
position = [corner[0] + dx * along + dz * across, corner[1] + up, corner[2] + dz * along + dx * across]
entry = [int(position[0] // 1), int(position[1] // 1), int(position[2] // 1)]
if tuple(entry) not in source:
entry = list(corner)
scale = 8.0 if from_nether else 1 / 8
approx = (int((position[0] * scale) // 1), int(position[1] // 1), int((position[2] * scale) // 1))
target, pois = {}, []
terrain(states, rng, target, approx, not from_nether)
radius = 128 if from_nether else 16
for _ in range(rng.choice([0, 0, 1, 1, 2, 3])):
reach = rng.choice([4, radius, radius + 6])
other = (approx[0] + rng.randint(-reach, reach), approx[1] + rng.randint(-10, 10), approx[2] + rng.randint(-reach, reach))
portal(states, target, pois, other, rng.random() < 0.5, rng.choice([2, 3]), rng.choice([3, 4]), rng.random() < 0.8)
if rng.random() < 0.25:
# A tight border near the exit.
border = {'x': approx[0] + rng.randint(-20, 20) + 0.5 * rng.randint(0, 1), 'z': approx[2] + rng.randint(-20, 20),
'size': rng.choice([4, 9, 16, 30, 60])}
else:
border = {'x': 0.0, 'z': 0.0, 'size': 59999968.0}
yield {'seed': rng.randrange(1 << 40), 'from': 'nether' if from_nether else 'overworld',
'source': [[*p, s] for p, s in source.items()], 'target': [[*p, s] for p, s in target.items()],
'pois': pois, 'entry': entry, 'entity': {'type': kind, 'pos': position, 'bits': [struct.pack('>d', v).hex() for v in position], 'dims': list(dims),
'reset_forward': kind not in ('minecraft:item', 'minecraft:arrow')}, 'border': border}
def main():
parser = h.argument_parser(__doc__)
args = parser.parse_args()
if args.count == 40000:
args.count = 1500
lock, jars, libraries = base.verify_artifacts()
facts = h.load_facts()
resources = lab.LOCAL / 'horizon-client' / lock['minecraft']['version']
work = lab.LOCAL / 'nether-portal-parity'
work.mkdir(parents=True, exist_ok=True)
all_cases = list(cases(facts, args.count, args.seed))
(work / 'cases.jsonl').write_text(''.join(json.dumps(case) + '\n' for case in all_cases))
classes = work / 'classes'
classes.mkdir(exist_ok=True)
dependencies = os.pathsep.join(map(str, [jars['server'], *libraries]))
java_root = lab.ROOT / 'mods/horizon/src/test/java'
h.run(['javac', '--release', str(lock['minecraft']['java_major']), '-proc:none', '-sourcepath', str(java_root), '-nowarn',
'-cp', dependencies, '-d', str(classes), str(java_root / 'dev/horizonlab/parity/VanillaPortalOracle.java')])
h.run(['java', '-Xmx3G', '-cp', str(classes) + os.pathsep + dependencies, 'dev.horizonlab.parity.VanillaPortalOracle',
str(resources), str(work / 'cases.jsonl'), str(work / 'native.txt')])
h.run(['cargo', 'run', '-q', '--release', '-p', 'horizon-world', '--example', 'portal_travel_fixture', '--',
str(resources), str(work / 'cases.jsonl'), str(work / 'rust.txt')], cwd=lab.ROOT)
native = h.split_cases((work / 'native.txt').read_text(), ())
rust = h.split_cases((work / 'rust.txt').read_text(), ())
assert len(native) == len(rust) == len(all_cases), (len(native), len(rust), len(all_cases))
groups, errors = {}, {}
created = found = 0
for case, a, b in zip(all_cases, native, rust):
if a and a[0].startswith('error'):
errors.setdefault(a[0], []).append(case)
continue
if any(line.startswith('set ') for line in a):
created += 1
elif not any(line == 'dest none' for line in a):
found += 1
if sorted(a) != sorted(b):
key = f"{case['from']} {case['entity']['type']} {'pois' if case['pois'] else 'no pois'}"
groups.setdefault(key, []).append((case, a, b))
for name, entries in sorted(errors.items(), key=lambda e: -len(e[1])):
print(f'oracle error x{len(entries)}: {name}')
for name, entries in sorted(groups.items(), key=lambda e: -len(e[1])):
print(f'{name}: {len(entries)} differing')
for case, a, b in entries[:args.show]:
print(f" case entry={case['entry']} entity={case['entity']} border={case['border']} pois={len(case['pois'])}")
print(' native ' + ' | '.join(sorted(a))[:1500])
print(' rust ' + ' | '.join(sorted(b))[:1500])
total = sum(len(v) for v in groups.values())
skipped = sum(len(v) for v in errors.values())
print(f'{len(all_cases) - total - skipped}/{len(all_cases) - skipped} cases match ({skipped} oracle errors); '
f'vanilla linked to an existing portal {found} times and built one {created} times')
h.finish(total + skipped)
if __name__ == '__main__':
main()