Merge remote-tracking branch 'pr/626' into HEAD

# Conflicts:
#	crates/horizon-client/src/lan/guest.rs
This commit is contained in:
Ludovic Marie
2026-10-17 05:42:28 +02:00
4 changed files with 181 additions and 30 deletions
+109 -22
View File
@@ -37,6 +37,11 @@ pub(super) struct GuestPlay {
swing: horizon_client::first_person::SwingState,
/// The block being dug and the face the client aimed at.
digging: Option<([i32; 3], [i32; 3])>,
/// The server tick the digging started (ServerPlayerGameMode.destroyProgressStart).
dig_start: u64,
/// A block the client stopped digging before the server's time was up: it breaks once
/// its progress since `dig_start` is complete (ServerPlayerGameMode.hasDelayedDestroy).
delayed: Option<([i32; 3], u64)>,
last_progress: i32,
/// Hand movements the client announced and the host animated.
swung: bool,
@@ -366,35 +371,41 @@ impl Game<'_> {
let face = direction(i32::from(a.direction));
let play = host.play.entry(conn).or_default();
play.digging = Some((a.pos, face));
play.dig_start = host.hub.ticks;
play.last_progress = -1;
// The pause between two blocks is the client's (MultiPlayerGameMode's
// destroyDelay); the server digs from the START it receives.
play.destroy_delay = 0;
}
1 => {}
2 | 3 => {
3 => {
host.hub.ack(conn, a.sequence);
self.guest_stop_digging(host, conn, a.pos);
}
2 => {
host.hub.ack(conn, a.sequence);
let play = host.play.entry(conn).or_default();
play.digging = None;
play.mining = None;
if a.action == 2 {
let state = self.world.block(a.pos[0], a.pos[1], a.pos[2]).0 as i32;
host.hub.send_to(
conn,
&C::BlockUpdate(play::BlockUpdate { pos: a.pos, state }),
);
host.hub.broadcast_near(
[
f64::from(a.pos[0]),
f64::from(a.pos[1]),
f64::from(a.pos[2]),
],
64.0,
&C::BlockDestruction(play::BlockDestruction {
id: host.hub.guests[gi].entity_id,
pos: a.pos,
progress: 255,
}),
Some(conn),
);
}
let state = self.world.block(a.pos[0], a.pos[1], a.pos[2]).0 as i32;
host.hub.send_to(
conn,
&C::BlockUpdate(play::BlockUpdate { pos: a.pos, state }),
);
host.hub.broadcast_near(
[
f64::from(a.pos[0]),
f64::from(a.pos[1]),
f64::from(a.pos[2]),
],
64.0,
&C::BlockDestruction(play::BlockDestruction {
id: host.hub.guests[gi].entity_id,
pos: a.pos,
progress: 255,
}),
Some(conn),
);
}
4 | 5 => {
if !spectator {
@@ -873,6 +884,7 @@ impl Game<'_> {
}
});
}
self.guest_delayed_destroy(host, conn);
self.guest_server_tick(host, conn);
self.guest_dig_feedback(host, conn);
self.guest_pickups(host, gi);
@@ -999,6 +1011,81 @@ impl Game<'_> {
})
}
/// ServerPlayerGameMode.handleBlockBreakAction, STOP_DESTROY_BLOCK: the client finished
/// digging `pos` (and predicted the break). The server breaks it if its own count of the
/// digging since START is at least 70 % done; otherwise it keeps digging alone and breaks
/// it when done (`guest_delayed_destroy`), so the client's broken block is never left
/// standing on the server.
fn guest_stop_digging(&mut self, host: &mut LanHost, conn: u32, pos: [i32; 3]) {
let ticks = host.hub.ticks;
let play = host.play.entry(conn).or_default();
let dug = play.digging.take().is_some_and(|(p, _)| p == pos);
play.mining = None;
let start = play.dig_start;
let state = self.world.block(pos[0], pos[1], pos[2]);
if !dug || self.res.facts.is_air(state) {
return;
}
let progress = self
.as_guest(host, conn, |g| g.destroy_progress(pos))
.map_or(0.0, |p| p * (ticks - start + 1) as f32);
if progress >= 0.7 {
self.guest_destroy(host, conn, pos);
} else {
let play = host.play.entry(conn).or_default();
if play.delayed.is_none() {
play.delayed = Some((pos, start));
}
}
}
/// ServerPlayerGameMode.tick's delayed destroy: the block breaks once its progress since
/// the digging started is complete, unless something else removed it first.
fn guest_delayed_destroy(&mut self, host: &mut LanHost, conn: u32) {
let Some((pos, start)) = host.play.get(&conn).and_then(|p| p.delayed) else {
return;
};
let ticks = host.hub.ticks;
let state = self.world.block(pos[0], pos[1], pos[2]);
let progress = if self.res.facts.is_air(state) {
None
} else {
self.as_guest(host, conn, |g| g.destroy_progress(pos))
.map(|p| p * (ticks - start + 1) as f32)
};
match progress {
Some(p) if p < 1.0 => {}
done => {
if let Some(play) = host.play.get_mut(&conn) {
play.delayed = None;
}
if done.is_some() {
self.guest_destroy(host, conn, pos);
}
}
}
}
/// ServerPlayerGameMode.destroyBlock for a guest, its crack cleared for the others
/// (`destroyBlockProgress(id, pos, -1)`).
fn guest_destroy(&mut self, host: &mut LanHost, conn: u32, pos: [i32; 3]) {
self.as_guest(host, conn, |g| {
let _ = g.break_block(pos);
});
if let Some(g) = host.hub.guest(conn) {
host.hub.broadcast_near(
[f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2])],
64.0,
&C::BlockDestruction(play::BlockDestruction {
id: g.entity_id,
pos,
progress: 255,
}),
Some(conn),
);
}
}
/// The crack animation other players see.
fn guest_dig_feedback(&mut self, host: &mut LanHost, conn: u32) {
let Some(gi) = host.hub.guests.iter().position(|g| g.conn == conn) else {
+57 -7
View File
@@ -89,6 +89,11 @@ pub(super) struct Remote {
was_sprinting: bool,
carried: Option<usize>,
loaded_sent: bool,
/// BlockStatePredictionHandler: blocks changed ahead of the server (a predicted break),
/// with the sequence of the last action that changed them and the state the server
/// last said they have. Until the server acknowledges that sequence its block updates
/// only replace the remembered state; then the block takes it.
predictions: HashMap<[i32; 3], (i32, i32)>,
/// Open container: (window id, menu name).
menu: Option<(i32, String)>,
/// The open menu's title as the server named it.
@@ -273,6 +278,7 @@ impl Game<'_> {
was_sprinting: false,
carried: None,
loaded_sent: false,
predictions: HashMap::new(),
menu: None,
menu_title: None,
state_id: 0,
@@ -541,6 +547,7 @@ impl Game<'_> {
r.dimension = dimension;
r.game_mode = spawn.game_type;
r.loaded_sent = false;
r.predictions.clear();
self.set_mode_id(spawn.game_type);
self.dim = if spawn.dimension == "minecraft:the_nether" {
Dim::Nether
@@ -668,6 +675,42 @@ impl Game<'_> {
}
}
}
/// ClientLevel.setServerVerifiedBlockState: a block the client predicted keeps its
/// predicted state until the server acknowledges the action; the server's state is
/// remembered for then.
fn server_block(&mut self, pos: [i32; 3], state: i32) {
if let Some((_, known)) = self
.remote
.as_mut()
.and_then(|r| r.predictions.get_mut(&pos))
{
*known = state;
return;
}
self.set_block(pos, state);
}
/// BlockStatePredictionHandler.endPredictionsUpTo (ClientboundBlockChangedAckPacket): the
/// actions up to `sequence` are settled, so the blocks they predicted take the state the
/// server gave them (a break the server refused comes back).
fn end_predictions(&mut self, sequence: i32) {
let Some(r) = self.remote.as_mut() else {
return;
};
let settled: Vec<_> = r
.predictions
.iter()
.filter(|(_, (s, _))| *s <= sequence)
.map(|(&pos, &(_, state))| (pos, state))
.collect();
for (pos, state) in settled {
if let Some(r) = self.remote.as_mut() {
r.predictions.remove(&pos);
}
if self.world.block(pos[0], pos[1], pos[2]).0 as i32 != state {
self.set_block(pos, state);
}
}
}
fn set_block(&mut self, pos: [i32; 3], state: i32) {
let state = BlockStateId(state.max(0) as u32);
if self.world.loaded(pos[0], pos[2])
@@ -913,7 +956,7 @@ impl Game<'_> {
chunks_per_tick: 64.0,
}));
}
C::BlockUpdate(p) => self.set_block(p.pos, p.state),
C::BlockUpdate(p) => self.server_block(p.pos, p.state),
C::SectionBlocksUpdate(p) => {
let [sx, sy, sz] = p.section;
for change in p.changes {
@@ -923,10 +966,10 @@ impl Game<'_> {
sy * 16 + (local & 15),
sz * 16 + (local >> 4 & 15),
];
self.set_block(pos, (change >> 12) as i32);
self.server_block(pos, (change >> 12) as i32);
}
}
C::BlockChangedAck(_) => {}
C::BlockChangedAck(p) => self.end_predictions(p.sequence),
// ClientLevel.blockEvent: BlockEntity.triggerEvent (chest lids,
// shulker boxes, bells) when the block is still the one it names.
C::BlockEvent(p) => {
@@ -2163,7 +2206,7 @@ impl Game<'_> {
self.send(S::Punch(Empty));
if self.creative {
let seq = self.next_sequence();
self.predict_break(hit.pos, state);
self.predict_break(hit.pos, state, seq);
self.send(S::PlayerAction(play::PlayerAction {
action: 0,
pos: hit.pos,
@@ -2212,7 +2255,7 @@ impl Game<'_> {
sequence: seq,
}));
if progress >= 1.0 {
self.predict_break(hit.pos, state);
self.predict_break(hit.pos, state, seq);
if let Some(r) = self.remote.as_mut() {
r.destroy_delay = 5;
}
@@ -2249,7 +2292,7 @@ impl Game<'_> {
self.crack_particle(pos, hit.face, state);
if done >= 1.0 {
let seq = self.next_sequence();
self.predict_break(pos, state);
self.predict_break(pos, state, seq);
self.send(S::PlayerAction(play::PlayerAction {
action: 3,
pos,
@@ -2281,7 +2324,14 @@ impl Game<'_> {
}
}
/// MultiPlayerGameMode.destroyBlock: the predicted break.
fn predict_break(&mut self, pos: [i32; 3], state: BlockStateId) {
fn predict_break(&mut self, pos: [i32; 3], state: BlockStateId, sequence: i32) {
// BlockStatePredictionHandler.retainKnownServerState.
if let Some(r) = self.remote.as_mut() {
r.predictions
.entry(pos)
.and_modify(|p| p.0 = sequence)
.or_insert((sequence, state.0 as i32));
}
let s = self.res.facts.get(state).sounds.clone();
let at = [
f64::from(pos[0]) + 0.5,
+3
View File
@@ -115,6 +115,8 @@ pub struct Guest {
pub sent_xp: Option<(f32, i32, i32)>,
/// Where the player last died (Player.lastDeathLocation), sent with the respawn.
pub last_death: Option<[i32; 3]>,
/// The last action sequence to acknowledge at the next tick (-1: none).
pub ack_up_to: std::cell::Cell<i32>,
pub sent_selected: usize,
pub inbox: VecDeque<play::Serverbound>,
pub joined_tick: u64,
@@ -199,6 +201,7 @@ impl Guest {
sent_health: None,
sent_xp: None,
last_death: None,
ack_up_to: std::cell::Cell::new(-1),
sent_selected: 0,
inbox: VecDeque::new(),
joined_tick: 0,
+12 -1
View File
@@ -899,6 +899,15 @@ impl Hub {
}
}
self.broadcast_block_changes(ctx.world);
// ServerGamePacketListenerImpl.tick: the actions handled since the last tick are
// acknowledged after the block changes they made were sent, so a client's predicted
// blocks settle on the server's states.
for g in &self.guests {
let sequence = g.ack_up_to.replace(-1);
if sequence >= 0 {
g.send(&C::BlockChangedAck(play::BlockChangedAck { sequence }));
}
}
self.sync_containers(ctx.world);
self.track_entities(ctx);
for i in 0..self.guests.len() {
@@ -1595,11 +1604,13 @@ impl Hub {
}
/// Acknowledge a block interaction (ClientboundBlockChangedAckPacket).
/// ServerGamePacketListenerImpl.ackBlockChangesUpTo: sent with the next tick's block
/// changes (`tick`).
pub fn ack(&self, conn: u32, sequence: i32) {
if sequence >= 0
&& let Some(g) = self.guest(conn)
{
g.send(&C::BlockChangedAck(play::BlockChangedAck { sequence }));
g.ack_up_to.set(g.ack_up_to.get().max(sequence));
}
}