diff --git a/crates/horizon-client/src/game/remote.rs b/crates/horizon-client/src/game/remote.rs index 45ba4bebe..1c7e30abb 100644 --- a/crates/horizon-client/src/game/remote.rs +++ b/crates/horizon-client/src/game/remote.rs @@ -140,8 +140,9 @@ pub(super) struct Remote { stepped: HashMap, /// `LivingEntity.lerpHeadTo`: the head yaw and the ticks left to reach it. head_lerps: HashMap, - /// Item entities waiting for their item data. - pending_items: HashMap, + /// Item entities waiting for their item data: where they are and their + /// motion. + pending_items: HashMap, health: (f32, i32, f32), game_mode: i32, pub chat: Vec<(String, Instant)>, @@ -1382,7 +1383,7 @@ impl Game<'_> { } if let Some(r) = self.remote.as_mut() { if kind == "minecraft:item" { - r.pending_items.insert(id, position); + r.pending_items.insert(id, (position, Vec3::ZERO)); } r.entities.insert( id, @@ -1461,6 +1462,23 @@ impl Game<'_> { m.on_ground = on_ground; return; } + if let Some(p) = r.pending_items.get_mut(&id) { + p.0 = position; + } + // ItemEntity and FallingBlockEntity keep Entity's NO_OP + // InterpolationHandler: moveOrInterpolateTo puts them there at + // once, and their own tick moves them on between the server's + // updates (`tick_remote_entities`). + let at = Vec3::new(position[0], position[1], position[2]); + if let Some(d) = self.dropped.iter_mut().find(|d| d.id == id as u32) { + d.position = at; + d.on_ground = on_ground; + return; + } + if let Some(f) = self.falling.iter_mut().find(|f| f.id == id as u32) { + f.position = at; + return; + } // AbstractInterpolationHandler.interpolateTo: without a rotation, // the one it was heading for. let rotation = rotation.or_else(|| r.lerps.get(&id).and_then(|l| l.rotation)); @@ -1472,9 +1490,6 @@ impl Game<'_> { steps: 3, }, ); - if let Some(p) = r.pending_items.get_mut(&id) { - *p = position; - } } self.turn_remote_object(id, rotation.map(|(yaw, _)| yaw), on_ground); self.turn_remote_projectile(id, rotation); @@ -1807,6 +1822,8 @@ impl Game<'_> { } } self.spawn_entity(p.id, &kind, p.position, rotation); + // Entity.recreateFromPacket: setDeltaMovement(packet.getMovement()). + self.remote_motion(p.id, p.velocity); if !self.spawn_remote_object(p.id, &kind, p.position, rotation[0], p.data) { self.spawn_remote_projectile( p.id, @@ -2125,6 +2142,8 @@ impl Game<'_> { pl.velocity = Vec3::new(p.velocity[0], p.velocity[1], p.velocity[2]); } } + // The same packet for another entity: Entity.lerpMotion. + C::SetEntityMotion(p) => self.remote_motion(p.id, p.velocity), // ClientPacketListener.handleDamageEvent: LivingEntity.handleDamageEvent // jolts the walk animation and restarts the hurt flash. Its hurt // sound comes as a sound from Horizon's host, which plays it itself. @@ -2933,7 +2952,9 @@ impl Game<'_> { item.stack = stack; return; } - let Some(p) = position else { return }; + let Some((p, velocity)) = position else { + return; + }; let at = Vec3::new(p[0], p[1], p[2]); let bob_offset = self.world.random.next_float() * std::f32::consts::PI * 2.0; self.dropped.push(ItemEntity { @@ -2944,7 +2965,7 @@ impl Game<'_> { stack, position: at, previous: at, - velocity: Vec3::ZERO, + velocity, on_ground: false, age: 0, pickup_delay: 0, @@ -2952,6 +2973,23 @@ impl Game<'_> { ticks: 0, }); } + /// `Entity.lerpMotion` (and `recreateFromPacket`'s motion) for the + /// entities whose own tick moves them on a client: dropped items and + /// falling blocks. + fn remote_motion(&mut self, id: i32, velocity: [f64; 3]) { + let v = Vec3::new(velocity[0], velocity[1], velocity[2]); + if let Some(d) = self.dropped.iter_mut().find(|d| d.id == id as u32) { + d.velocity = v; + } else if let Some(f) = self.falling.iter_mut().find(|f| f.id == id as u32) { + f.velocity = v; + } else if let Some(p) = self + .remote + .as_mut() + .and_then(|r| r.pending_items.get_mut(&id)) + { + p.1 = v; + } + } fn apply_remote_health(&mut self) { let Some((health, food, saturation)) = self.remote.as_ref().map(|r| r.health) else { return; @@ -3471,20 +3509,12 @@ impl Game<'_> { l.steps -= 1; } } + // ItemEntity.tick runs on a client too: gravity, collisions and + // friction move the item between the server's updates (every 20 + // ticks), and only the server removes it. + let (world, facts, collision) = (&self.world, self.res.facts(), self.collision); for d in self.dropped.iter_mut().filter(|_| running) { - d.previous = d.position; - d.age += 1; - if let Some(l) = lerps.get_mut(&(d.id as i32)) - && l.steps > 0 - { - let n = f64::from(l.steps); - d.position = Vec3::new( - d.position.x + (l.target[0] - d.position.x) / n, - d.position.y + (l.target[1] - d.position.y) / n, - d.position.z + (l.target[2] - d.position.z) / n, - ); - l.steps -= 1; - } + d.tick(world, facts, collision, false); } head_lerps.retain(|_, (_, steps)| *steps > 0); for (item, ticks, at, eye, pitch, yaw) in using { diff --git a/crates/horizon-client/src/game/remote_projectiles.rs b/crates/horizon-client/src/game/remote_projectiles.rs index 58f82e3a9..33c69728b 100644 --- a/crates/horizon-client/src/game/remote_projectiles.rs +++ b/crates/horizon-client/src/game/remote_projectiles.rs @@ -2,7 +2,7 @@ //! end crystals on a server's client (`ClientPacketListener.handleAddEntity` //! and `handleSetEntityData`): the server simulates them, the client draws //! them where it says and interpolates their moves. -use super::{FallingBlock, Game}; +use super::{FallStep, FallingBlock, Game}; use horizon_client::projectiles::{Projectile, ProjectileKind}; use horizon_core::{geometry::Vec3, position::BlockPos}; use horizon_protocol::entity_data::Value; @@ -185,11 +185,17 @@ impl Game<'_> { t.previous = t.position; t.position = step(t.id, t.position); } - for f in &mut self.falling { - f.previous = f.position; - f.age += 1; - f.position = step(f.id, f.position); + // FallingBlockEntity.tick runs on a client too: the block falls by + // itself between the server's updates (every 20 ticks), then waits + // where it lands for the server to place it and remove it. + let mut falling = std::mem::take(&mut self.falling); + for f in &mut falling { + if let Ok(FallStep::Landed(_)) = self.fall_step(f, false) { + // Block.updateEntityMovementAfterFallOn, then the air drag. + f.velocity = Vec3::new(f.velocity.x * 0.98, 0.0, f.velocity.z * 0.98); + } } + self.falling = falling; for p in &mut self.creatures.projectiles { p.previous = p.position; p.age += 1; diff --git a/tools/lan_e2e.py b/tools/lan_e2e.py index 3ece4b448..a0fe0e181 100755 --- a/tools/lan_e2e.py +++ b/tools/lan_e2e.py @@ -228,6 +228,9 @@ address. The script then checks, from both sides, what a guest's game used to ge - villagers: the guest sees each villager's and zombie villager's type, profession and level as the host has them, and an unemployed villager that takes a composter becomes a farmer on the guest too (the guest used to draw every villager as an unemployed plains one). +- falling: an item and a falling block the host summons high up fall smoothly on the guest, a + little further every tick between the server's updates (every 20 ticks), as their own + client tick moves them (they used to hang, then jump down once a second, #1568). Each check is reported on its own (a failing one doesn't stop the others) and the screenshots of both sides go to --out (host-*.png, guest-*.png). @@ -5496,5 +5499,46 @@ CHECKS += ['villagers'] CHECK_FNS.update(villagers=check_villagers) +def check_falling(host, guest, out): + """ItemEntity and FallingBlockEntity tick on a client too (gravity, collisions, drag), and their + position packets snap them (Entity's NO_OP InterpolationHandler). The server sends an item's + and a falling block's position every 20 ticks, so between two updates the guest's own tick is + what moves them: sampled every 2 ticks over the first 16, both are lower nearly every time.""" + x, y, z = (int(v // 1) for v in pos_of(guest)) + top = y + 30 + tag = 'falling_e2e' + host('command', command=f'fill {x + 2} {y} {z - 1} {x + 4} {top + 2} {z + 1} minecraft:air') + host('command', command=f'summon minecraft:item {x + 3.5} {top} {z + 0.5} ' + f'{{Tags:["{tag}"],Item:{{id:"minecraft:diamond",count:1}},PickupDelay:32767}}') + host('command', command=f'summon minecraft:falling_block {x + 2.5} {top} {z - 0.5} ' + f'{{Tags:["{tag}"],BlockState:{{Name:"minecraft:sand"}},DropItem:0b}}') + heights = {'item': [], 'falling block': []} + try: + for _ in range(8): + items = [e['pos'][1] for e in guest.raw('entities', 48, 'minecraft:item')['entities'] + if abs(e['pos'][0] - x - 3.5) < 0.5 and abs(e['pos'][2] - z - 0.5) < 0.5] + blocks = [o['position'][1] for o in guest('status')['projectiles'] + if o.get('kind') == 'minecraft:falling_block' + and abs(o['position'][0] - x - 2.5) < 0.5 and abs(o['position'][2] - z + 0.5) < 0.5] + heights['item'].append(items[0] if items else None) + heights['falling block'].append(blocks[0] if blocks else None) + guest.wait(2) + guest.shot(out, 'falling') + finally: + host('command', command=f'kill @e[tag={tag}]') + host('command', command=f'fill {x + 2} {y} {z - 1} {x + 4} {top + 2} {z + 1} minecraft:air') + for name, ys in heights.items(): + seen = [h for h in ys if h is not None] + assert len(seen) >= 6, f'the guest saw the {name} {len(seen)} times of 8: {heights}' + drops = sum(b < a for a, b in zip(seen, seen[1:])) + # A tick or two can pass between two samples with no move; never most of them. + assert drops >= len(seen) - 2, f'the {name} fell in {drops} of {len(seen) - 1} samples: {heights}' + return heights + + +CHECKS += ['falling'] +CHECK_FNS.update(falling=check_falling) + + if __name__ == '__main__': main()