Merge pull request #1465 from ludovic111/fix/st-signs

🤖 Agent: merged after verify and CI parity passed, built merged with current main (st-default-1: server-thread gaps checked against vanilla, each with a lan_e2e check that fails on main and passes here, host and guest, both modes; tables in the PR body).
This commit is contained in:
Ludovic Marie
2026-10-24 03:38:08 +02:00
committed by GitHub
8 changed files with 234 additions and 19 deletions
+6
View File
@@ -335,6 +335,12 @@ impl Game<'_> {
Some(Ticker::Shulker { .. }) => v["lid"] = json!(self.block_anim(pos, 1.0).shulker.0),
_ => {}
}
// The lines of a sign, as this client has them.
if let Some(horizon_client::containers::BlockEntity::Sign(sign)) =
self.world.block_entities.get(&(pos[0], pos[1], pos[2]))
{
v["sign"] = json!({ "front": sign.front.lines, "back": sign.back.lines });
}
v
}
pub(super) fn stack_value(&self, s: &ItemStack) -> Value {
+12 -1
View File
@@ -232,6 +232,13 @@ impl Game<'_> {
"key" => {
let key = key_code(arg(1)?).ok_or_else(|| format!("unknown key {}", words[1]))?;
self.require_world()?;
// The sign editor takes raw presses (Enter, arrows, Backspace, Escape).
if self.sign_edit.is_some() {
if arg(2)? != "up" {
self.sign_input(Some(key), None);
}
return ok();
}
// A held edit modifier (`key super down`) and A/C/V/X: the
// open book's Select All, Copy, Paste or Cut.
if self.book.is_some() && arg(2)? != "up" {
@@ -524,6 +531,10 @@ impl Game<'_> {
self.book_type(text);
return ok();
}
if self.sign_edit.is_some() {
self.sign_input(None, Some(text));
return ok();
}
match self.screen {
Screen::Chat => self.chat_type(text),
Screen::CommandBlock => self.command_block_type(text),
@@ -549,7 +560,7 @@ impl Game<'_> {
}
_ => {
return Err(
"type needs the chat screen (key t tap), the language search, the creative search, the anvil or World Options".into(),
"type needs the chat screen (key t tap), a sign or book, the language search, the creative search, the anvil or World Options".into(),
);
}
}
@@ -30,6 +30,8 @@ use winit::keyboard::KeyCode;
/// Per-guest state of the gameplay code that lives outside `Guest`.
#[derive(Default)]
pub(super) struct GuestPlay {
/// The sign this guest may write on (`SignBlockEntity.playerWhoMayEdit`).
pub(super) sign_editing: Option<[i32; 3]>,
mining: Option<Mining>,
destroy_delay: u32,
using: Option<(usize, u32)>,
@@ -513,7 +515,8 @@ impl Game<'_> {
std::mem::swap(&mut self.mount, &mut play.mount);
self.container = container;
self.screen = screen;
self.sign_edit = host_sign;
// A sign the guest's placement opened (SignBlock.openTextEdit).
let guest_sign = std::mem::replace(&mut self.sign_edit, host_sign);
// A lectern the guest's use opened (LecternBlock.openScreen).
let guest_lectern = match std::mem::replace(&mut self.book, host_book) {
Some(super::books::BookScreen::View {
@@ -652,6 +655,9 @@ impl Game<'_> {
if let Some(station) = opened_station {
self.lan_station_opened(host, conn, station);
}
if let Some(edit) = guest_sign {
self.lan_open_sign_editor(host, conn, edit);
}
if let Some(key) = guest_lectern {
self.lan_open_lectern(host, conn, key);
}
@@ -1033,6 +1039,7 @@ impl Game<'_> {
self.lan_station_button(host, conn, p.container, p.button);
}
S::RenameItem(p) => self.lan_station_rename(host, conn, &p.name),
S::SignUpdate(p) => self.lan_sign_update(host, conn, p),
S::ContainerSlotStateChanged(p) => {
self.lan_crafter_slot_state(host, conn, p.container, p.slot, p.enabled);
}
+16 -11
View File
@@ -588,17 +588,7 @@ impl Game<'_> {
let [x, y, z] = gs.pos;
let name = &self.res.facts().get(self.world.block(x, y, z)).name;
let block = StationKind::from_block(name) == Some(gs.kind);
let eye = [g.position[0], g.position[1] + g.eye_height(), g.position[2]];
// The block interaction range (4.5, creative 5) and the buffer.
let reach = if g.creative() { 5.0 } else { 4.5 } + 4.0;
let near = (0..3)
.map(|k| {
let lo = f64::from(gs.pos[k]);
(lo - eye[k]).max(eye[k] - lo - 1.0).max(0.0).powi(2)
})
.sum::<f64>()
< reach * reach;
if !(block && near) {
if !(block && within_reach(g, gs.pos)) {
let window = gs.window;
self.lan_station_closed(host, conn, Some(window));
host.hub.send_to(
@@ -670,3 +660,18 @@ pub(super) fn station_inputs(gs: &GuestStation) -> Vec<ItemStack> {
.map(|(_, _, inputs)| inputs.filter_map(|s| gs.menu.slot(s).cloned()).collect())
.unwrap_or_default()
}
/// `Player.isWithinBlockInteractionRange(pos, 4)`: the guest's eyes within
/// its block interaction range (4.5, creative 5) and a 4-block buffer of the
/// block's box.
pub(super) fn within_reach(g: &horizon_client::lan::guest::Guest, pos: [i32; 3]) -> bool {
let eye = [g.position[0], g.position[1] + g.eye_height(), g.position[2]];
let reach = if g.creative() { 5.0 } else { 4.5 } + 4.0;
(0..3)
.map(|k| {
let lo = f64::from(pos[k]);
(lo - eye[k]).max(eye[k] - lo - 1.0).max(0.0).powi(2)
})
.sum::<f64>()
< reach * reach
}
+1
View File
@@ -2557,6 +2557,7 @@ impl Game<'_> {
self.drop_remote_chunks_out_of_range();
}
C::BlockEntityData(p) => self.remote_block_entity_data(p.pos, p.kind, &p.tag),
C::OpenSignEditor(p) => self.remote_open_sign_editor(p),
// handleSetSpawn: ClientLevel.setRespawnData, which spawn compasses point at.
C::SetDefaultSpawnPosition(p) => {
let [x, y, z] = p.pos.pos;
+86 -4
View File
@@ -1,12 +1,13 @@
//! The sign editing screen (`SignEditScreen` / `HangingSignEditScreen`):
//! opened when a sign is placed, four lines limited to the sign's line
//! width, Up/Down/Enter move between lines, Escape or Done closes.
use super::Game;
use super::{Game, lan::LanHost};
use horizon_client::{
containers::BlockEntity,
hud::{HudBatch, rgba},
signs::wood_type,
};
use horizon_protocol::packets::play::{self, Clientbound as C, Serverbound as S};
use std::time::Instant;
use winit::{
event::{ElementState, KeyEvent},
@@ -33,14 +34,95 @@ impl Game<'_> {
self.right = false;
self.capture(false);
}
/// `AbstractSignEditScreen.removed`: a server's client sends what it
/// wrote (ServerboundSignUpdatePacket); the window's own world keeps it
/// and sends it to its guests (`sendBlockUpdated`).
pub(super) fn close_sign_editor(&mut self) {
if let Some(edit) = self.sign_edit.take() {
self.world
.modified
.insert((edit.pos.0 >> 4, edit.pos.2 >> 4));
if self.remote.is_some() {
if let Some(BlockEntity::Sign(sign)) = self.world.block_entities.get(&edit.pos) {
let side = if edit.front { &sign.front } else { &sign.back };
self.send(S::SignUpdate(play::SignUpdate {
pos: [edit.pos.0, edit.pos.1, edit.pos.2],
lines: side.lines.clone(),
front: edit.front,
}));
}
} else {
self.mark_block_entity_updated(edit.pos);
}
}
self.capture(true);
}
/// `ServerPlayer.openTextEdit` for the guest whose action opened a sign:
/// the block, then the editor, on its client, and the guest may write on it.
pub(super) fn lan_open_sign_editor(&mut self, host: &mut LanHost, conn: u32, edit: SignEditor) {
let pos = [edit.pos.0, edit.pos.1, edit.pos.2];
let state = self.world.block(pos[0], pos[1], pos[2]).0 as i32;
host.hub
.send_to(conn, &C::BlockUpdate(play::BlockUpdate { pos, state }));
host.hub.send_to(
conn,
&C::OpenSignEditor(play::OpenSignEditor {
pos,
front: edit.front,
}),
);
host.play.entry(conn).or_default().sign_editing = Some(pos);
}
/// `ServerGamePacketListenerImpl.handleSignUpdate`: the lines, formatting
/// codes stripped, go on the sign the guest may write on unless it is
/// waxed (`SignBlockEntity.updateSignText`); a guest gone out of reach
/// may no longer write (`playerIsTooFarAwayToEdit`).
pub(super) fn lan_sign_update(&mut self, host: &mut LanHost, conn: u32, p: play::SignUpdate) {
let Some(g) = host.hub.guest(conn) else {
return;
};
let near = super::lan_stations::within_reach(g, p.pos);
let Some(play) = host.play.get_mut(&conn) else {
return;
};
if !near {
play.sign_editing = None;
}
if play.sign_editing != Some(p.pos) {
log::warn!("{} just tried to change non-editable sign", g.name);
return;
}
let key = (p.pos[0], p.pos[1], p.pos[2]);
let Some(BlockEntity::Sign(sign)) = self.world.block_entities.get_mut(&key) else {
return;
};
if sign.waxed {
return;
}
let side = if p.front {
&mut sign.front
} else {
&mut sign.back
};
for (line, new) in side.lines.iter_mut().zip(&p.lines) {
*line = horizon_client::clipboard::strip_formatting(new);
}
play.sign_editing = None;
self.mark_block_entity_updated(key);
}
/// `ClientPacketListener.handleOpenSignEditor`: the editor on a sign this
/// client has.
pub(super) fn remote_open_sign_editor(&mut self, p: play::OpenSignEditor) {
let key = (p.pos[0], p.pos[1], p.pos[2]);
if matches!(
self.world.block_entities.get(&key),
Some(BlockEntity::Sign(_))
) {
self.open_sign_editor(key, p.front);
} else {
log::warn!(
"ignoring openTextEdit on a block that is no sign at {:?}",
p.pos
);
}
}
pub(super) fn sign_edit_key(&mut self, event: &KeyEvent) {
if event.state != ElementState::Pressed {
return;
@@ -461,6 +461,10 @@ packet!(OpenScreen { container: i32 => VarInt, menu: i32 => VarInt, title: Tag =
// ClientboundMountScreenOpenPacket: a horse's or llama's inventory, with its
// chest's columns (`getInventoryColumns`).
packet!(MountScreenOpen { container: i32 => VarInt, columns: i32 => VarInt, entity: i32 => Int });
packet!(
/// ClientboundOpenSignEditorPacket: the sign whose side the player edits.
OpenSignEditor { pos: [i32; 3] => Pos, front: bool => SignSide }
);
packet!(PlayerAbilities { flags: i8 => Byte, flying_speed: f32 => Float, walking_speed: f32 => Float });
/// MessageSignature.Packed: an index into the last-seen cache or a full signature.
pub struct PackedSignature;
@@ -1617,6 +1621,7 @@ packet_enum!(Clientbound, crate::ids::play::clientbound {
MerchantOffers(MerchantOffers) = MERCHANT_OFFERS,
MountScreenOpen(MountScreenOpen) = MOUNT_SCREEN_OPEN,
OpenScreen(OpenScreen) = OPEN_SCREEN,
OpenSignEditor(OpenSignEditor) = OPEN_SIGN_EDITOR,
Ping(Ping) = PING,
PongResponse(crate::packets::status::Ping) = PONG_RESPONSE,
PlayerAbilities(PlayerAbilities) = PLAYER_ABILITIES,
@@ -1917,6 +1922,38 @@ packet!(
/// ServerboundRenameItemPacket: `AnvilMenu.setItemName`.
RenameItem { name: String => Str }
);
packet!(
/// ServerboundSignUpdatePacket: the four lines the player wrote on a side.
SignUpdate { pos: [i32; 3] => Pos, lines: [String; 4] => SignLines, front: bool => SignSide }
);
/// SignTextSlot.STREAM_CODEC: VarInt 0 for the back, 1 for the front (any
/// other id reads as the back, ByIdMap's ZERO strategy).
pub struct SignSide;
impl Codec<bool> for SignSide {
fn read(r: &mut Reader) -> Result<bool> {
Ok(r.varint()? == 1)
}
fn write(v: &bool, w: &mut Writer) {
w.varint(i32::from(*v));
}
}
/// `stringUtf8(384)` in `fixedSizeList(4)`: four lines, no count.
pub struct SignLines;
impl Codec<[String; 4]> for SignLines {
fn read(r: &mut Reader) -> Result<[String; 4]> {
Ok([
r.string(384)?,
r.string(384)?,
r.string(384)?,
r.string(384)?,
])
}
fn write(v: &[String; 4], w: &mut Writer) {
for line in v {
w.string(line);
}
}
}
packet!(
/// ServerboundSetBeaconPacket: `BeaconMenu.updateEffects`, each power an
/// optional `mob_effect` id.
@@ -2024,6 +2061,7 @@ packet_enum!(Serverbound, crate::ids::play::serverbound {
SetBeacon(SetBeacon) = SET_BEACON,
SetCarriedItem(SetCarriedItem) = SET_CARRIED_ITEM,
SetCreativeModeSlot(SetCreativeModeSlot) = SET_CREATIVE_MODE_SLOT,
SignUpdate(SignUpdate) = SIGN_UPDATE,
UseItem(UseItem) = USE_ITEM,
UseItemOn(UseItemOn) = USE_ITEM_ON,
});
@@ -2748,4 +2786,29 @@ mod tests {
});
round_trip(p, Clientbound::encode, Clientbound::decode);
}
#[test]
fn sign_packets_match_vanilla_stream_codecs() {
// ClientboundOpenSignEditorPacket: BlockPos, then SignTextSlot as a VarInt (FRONT is 1).
let open = Clientbound::OpenSignEditor(OpenSignEditor {
pos: [1, 2, 3],
front: true,
});
let body = open.encode();
assert_eq!(
body[1..9],
crate::buf::pack_block_pos([1, 2, 3]).to_be_bytes()
);
assert_eq!(body[9..], [1]);
round_trip(open, Clientbound::encode, Clientbound::decode);
// ServerboundSignUpdatePacket: BlockPos, four strings with no count, then the slot.
let update = Serverbound::SignUpdate(SignUpdate {
pos: [-4, 70, 9],
lines: ["Hi".into(), String::new(), "x".into(), String::new()],
front: false,
});
let body = update.encode();
assert_eq!(body[9..], [2, b'H', b'i', 0, 1, b'x', 0, 0]);
round_trip(update, Serverbound::encode, Serverbound::decode);
}
}
+42 -2
View File
@@ -192,6 +192,9 @@ address. The script then checks, from both sides, what a guest's game used to ge
- keepinv: the host and the guest each die holding diamonds and wearing a helmet: with keep_inventory
off both drop where they died and the player respawns without them; with it on nothing
drops and the player keeps them (#1284).
- signs: the host and the guest each place an oak sign: the editor opens on their own screen
(ClientboundOpenSignEditorPacket), the two lines they write reach the server
(ServerboundSignUpdatePacket) and both sides show them (#1380).
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).
@@ -4569,8 +4572,45 @@ def check_keep_inventory(host, guest, out):
return seen
CHECKS += ['totem', 'keepinv']
CHECK_FNS.update(totem=check_totem, keepinv=check_keep_inventory)
def check_signs(host, guest, out):
"""SignBlock.openTextEdit on the placing player's client, for the host and the guest: placing
an oak sign opens its editor there and nowhere else, the lines typed into it go to the server
when it closes, and both sides then show them (#1380)."""
hx, hy, hz = (int(v // 1) for v in pos_of(host))
seen = {}
for game, other, dz in ((host, guest, -2), (guest, host, 2)):
spot = (hx + 2, hy, hz + dz)
game('command', command=f'setblock {spot[0]} {spot[1] - 1} {spot[2]} minecraft:stone')
game('command', command=f'setblock {spot[0]} {spot[1]} {spot[2]} minecraft:air')
game('command', command='gamemode survival')
game('command', command='clear @s')
game('command', command='give @s minecraft:oak_sign 1')
game.wait(10)
game.raw('place', *spot, '--item', 'minecraft:oak_sign')
game.wait(10)
opened = {g.name: g('state').get('screen') for g in (game, other)}
game.shot(out, 'signs-editor')
lines = [f'{game.name} wrote', 'line two']
game.raw('type', lines[0])
game.raw('key', 'enter', 'tap')
game.raw('type', lines[1])
game.raw('key', 'esc', 'tap')
game.wait(20)
back_to_game(other)
seen[game.name] = {'opened': opened,
'shown': {g.name: (g.raw('block', *spot).get('sign') or {}).get('front')
for g in (game, other)}}
other.shot(out, 'signs-shown')
for name, s in seen.items():
other = 'guest' if name == 'host' else 'host'
want = [f'{name} wrote', 'line two', '', '']
assert s['opened'] == {name: 'sign', other: 'playing'}, f'{name}: {seen}'
assert s['shown'] == {name: want, other: want}, f'{name}: {seen}'
return seen
CHECKS += ['totem', 'keepinv', 'signs']
CHECK_FNS.update(totem=check_totem, keepinv=check_keep_inventory, signs=check_signs)
if __name__ == '__main__':