Command suggestions: ask the server for nodes the tree marks ask_server

A remote client's chat now sends ServerboundCommandSuggestionPacket for an
argument node whose provider is minecraft:ask_server (bossbar ids, data
storage, datapacks, team names, functions...), as ClientSuggestionProvider.customSuggestion
does. The suggestions are done when ClientboundCommandSuggestionsPacket
answers that id; its completions join the local ones (Suggestions.merge).
Replies to older requests are dropped.

The remote tree takes each node's provider from the packet only: a local
provider the server didn't send stood in for the server's before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-18 00:04:14 +02:00
parent 9f7bd91109
commit ff6e01de03
7 changed files with 257 additions and 16 deletions
+83 -5
View File
@@ -386,6 +386,12 @@ pub struct ChatScreen {
parse: Option<ParseResults>,
/// The completions at the cursor (`pendingSuggestions`): range start (bytes) and list.
pending: Option<(usize, Vec<Suggestion>)>,
/// Completions waiting for the server's (an `ask_server` node at the
/// cursor): `pendingSuggestions` is not done until they come.
awaiting: Option<Awaiting>,
/// The request to send (`ServerboundCommandSuggestionPacket`): id and
/// the command up to the cursor.
request: Option<(i32, String)>,
suggestions: Option<SuggestionList>,
usage: Vec<Text>,
usage_position: i32,
@@ -394,6 +400,16 @@ pub struct ChatScreen {
keep_suggestions: bool,
pub auto_suggestions: bool,
}
/// Local completions waiting for the server's reply to request `id`.
struct Awaiting {
id: i32,
/// The command up to the cursor, as sent.
truncated: String,
local: Vec<Suggestion>,
}
/// `ClientSuggestionProvider.pendingSuggestionsId`: one counter for the
/// connection, so a reply to an older request never matches.
static SUGGESTION_ID: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(0);
/// `CommandSuggestions`' fill colour.
const FILL: i32 = -805306368;
fn byte_at(s: &str, chars: usize) -> usize {
@@ -442,6 +458,8 @@ impl ChatScreen {
history_pos: history_len,
parse: None,
pending: None,
awaiting: None,
request: None,
suggestions: None,
usage: Vec::new(),
usage_position: 0,
@@ -518,24 +536,84 @@ impl ChatScreen {
}
if cursor >= 1 && (self.suggestions.is_none() || !self.keep_suggestions) {
let parse = self.parse.as_ref().expect("parsed above");
let (range, list) = c
.dispatcher
.client_suggestions(parse, cursor_b, c.registries);
self.pending = Some((range.0, list));
self.update_usage_info(m, c);
let (range, list, ask) =
c.dispatcher
.client_suggestions_asking(parse, cursor_b, c.registries);
if ask {
// ClientSuggestionProvider.customSuggestion: the
// suggestions are done when the server answers.
let id = SUGGESTION_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1;
let truncated = command[..cursor_b].to_owned();
self.request = Some((id, truncated.clone()));
self.awaiting = Some(Awaiting {
id,
truncated,
local: list,
});
self.pending = None;
} else {
self.awaiting = None;
self.pending = Some((range.0, list));
self.update_usage_info(m, c);
}
}
} else if !command.chars().all(char::is_whitespace) {
let partial = &command[..cursor_b];
let mut builder = SuggestionsBuilder::new(partial, last_word_index(partial));
builder.suggest_matching(c.registries.players.iter().map(String::as_str));
let (range, list) = merge_suggestions(partial, builder.out);
self.awaiting = None;
self.pending = Some((range.0, list));
self.usage_width = 0;
self.usage_position = 0;
} else {
self.awaiting = None;
self.pending = None;
}
}
/// The completion request to send to the server, if one is waiting.
pub fn take_request(&mut self) -> Option<(i32, String)> {
self.request.take()
}
/// `ClientSuggestionProvider.completeCustomSuggestions`: the server's
/// completions for request `id`, with `range` in UTF-16 units of the
/// command sent. They join the local ones (`Suggestions.merge`) and the
/// pending suggestions are done.
pub fn server_suggestions(
&mut self,
m: &Measure,
c: &Commands,
id: i32,
range: (usize, usize),
list: Vec<(String, Option<String>)>,
) {
let Some(awaiting) = self.awaiting.take_if(|a| a.id == id) else {
return;
};
let input = &awaiting.truncated;
let byte = |units: usize| {
let mut n = 0;
input
.char_indices()
.find(|(_, ch)| {
let past = n >= units;
n += ch.len_utf16();
past
})
.map_or(input.len(), |(i, _)| i)
};
let range = (byte(range.0), byte(range.0 + range.1));
let mut all = awaiting.local;
all.extend(list.into_iter().map(|(text, tooltip)| Suggestion {
range,
text,
tooltip,
int_value: None,
}));
let (range, list) = merge_suggestions(input, all);
self.pending = Some((range.0, list));
self.update_usage_info(m, c);
}
/// `CommandSuggestions.updateUsageInfo`.
fn update_usage_info(&mut self, m: &Measure, c: &Commands) {
let Some(parse) = &self.parse else { return };
+55
View File
@@ -230,3 +230,58 @@ fn mod_commands_are_coloured_and_complete_like_vanilla_ones() {
screen.key(&m, &c, &[], winit::keyboard::KeyCode::Tab, false, false);
assert_eq!(screen.value(), "/coords");
}
#[test]
fn ask_server_nodes_wait_for_the_servers_completions() {
// ClientSuggestionProvider.customSuggestion: an `ask_server` node at the
// cursor sends the command so far, and the list is done with the reply.
let font = font();
let m = Measure(&font);
let registries = Registries {
permission: 4,
..Registries::default()
};
let mut d = crate::command::vanilla::game_dispatcher().clone();
let child = |d: &crate::command::Dispatcher, n: usize, name: &str| {
d.nodes[n]
.children
.iter()
.copied()
.find(|&c| d.nodes[c].name() == name)
.expect(name)
};
let id = child(&d, child(&d, child(&d, 0, "bossbar"), "get"), "id");
d.nodes[id].suggests = Some(crate::command::Suggests::AskServer);
let c = Commands {
dispatcher: &d,
registries: &registries,
};
let tab = |screen: &mut ChatScreen| {
screen.key(&m, &c, &[], winit::keyboard::KeyCode::Tab, false, false);
};
let mut screen = ChatScreen::new(&m, &c, "", 0, 640, 360);
screen.type_text(&m, &c, "/bossbar get pt");
let (request, sent) = screen.take_request().expect("the server is asked");
assert_eq!(sent, "/bossbar get pt");
assert_eq!(screen.take_request(), None);
// Nothing to complete until the reply.
tab(&mut screen);
assert_eq!(screen.value(), "/bossbar get pt");
// A reply to an older request is dropped; the range is in UTF-16 units.
let reply = |text: &str| vec![(text.to_owned(), None)];
screen.server_suggestions(&m, &c, request - 1, (13, 2), reply("pt6:old"));
tab(&mut screen);
assert_eq!(screen.value(), "/bossbar get pt");
screen.server_suggestions(&m, &c, request, (13, 2), reply("pt6:check"));
tab(&mut screen);
assert_eq!(screen.value(), "/bossbar get pt6:check");
// Without the server's provider the local list is done at once.
let local = crate::command::vanilla::game_dispatcher();
let c = Commands {
dispatcher: local,
registries: &registries,
};
let mut screen = ChatScreen::new(&m, &c, "", 0, 640, 360);
screen.type_text(&m, &c, "/bossbar get pt");
assert_eq!(screen.take_request(), None);
}
+23 -4
View File
@@ -312,6 +312,9 @@ pub enum Suggests {
/// ScoreboardCommand.suggestTriggers: trigger objectives some of the
/// parsed `targets` have no score in, or a locked one.
EnableTriggers,
/// SuggestionProviders.ASK_SERVER: the server completes the node
/// (ClientSuggestionProvider.customSuggestion); nothing locally.
AskServer,
}
impl Node {
pub fn name(&self) -> &str {
@@ -691,7 +694,7 @@ impl Suggests {
Suggests::Triggers => {
builder.suggest_matching(reg.trigger_objectives.iter().map(String::as_str))
}
Suggests::Nothing => {}
Suggests::Nothing | Suggests::AskServer => {}
}
}
}
@@ -955,7 +958,8 @@ impl Dispatcher {
cursor: usize,
reg: &Registries,
) -> (Range, Vec<Suggestion>) {
self.suggestions_within(parse, cursor, reg, u8::MAX)
let (range, list, _) = self.suggestions_within(parse, cursor, reg, u8::MAX);
(range, list)
}
/// The suggestions the player's chat shows: the client's tree only holds
/// the nodes the player may use (Commands.sendCommands prunes by canUse).
@@ -965,6 +969,18 @@ impl Dispatcher {
cursor: usize,
reg: &Registries,
) -> (Range, Vec<Suggestion>) {
let (range, list, _) = self.suggestions_within(parse, cursor, reg, reg.permission);
(range, list)
}
/// [`Self::client_suggestions`], and whether a node at the cursor asks
/// the server (`ask_server`): its completions come with the server's
/// reply, to be merged with these.
pub fn client_suggestions_asking(
&self,
parse: &ParseResults,
cursor: usize,
reg: &Registries,
) -> (Range, Vec<Suggestion>, bool) {
self.suggestions_within(parse, cursor, reg, reg.permission)
}
fn suggestions_within(
@@ -973,15 +989,17 @@ impl Dispatcher {
cursor: usize,
reg: &Registries,
permission: u8,
) -> (Range, Vec<Suggestion>) {
) -> (Range, Vec<Suggestion>, bool) {
let (parent, start, context) = parse.context.suggestion_context(cursor);
let start = start.min(cursor);
let truncated = &parse.input[..cursor.min(parse.input.len())];
let mut all = Vec::new();
let mut ask = false;
for &child in &self.nodes[parent].children {
if self.nodes[child].permission > permission {
continue;
}
ask |= matches!(self.nodes[child].suggests, Some(Suggests::AskServer));
let mut builder = SuggestionsBuilder::new(truncated, start);
match &self.nodes[child].kind {
NodeKind::Literal(l) => {
@@ -997,7 +1015,8 @@ impl Dispatcher {
}
all.extend(builder.out);
}
merge_suggestions(truncated, all)
let (range, list) = merge_suggestions(truncated, all);
(range, list, ask)
}
fn smart_usage_of(&self, node: usize, optional: bool, deep: bool, level: u8) -> Option<String> {
let n = &self.nodes[node];
+5 -6
View File
@@ -83,10 +83,9 @@ pub fn from_packet(packet: &Commands, local: &Dispatcher) -> Dispatcher {
}
_ => NodeKind::Root,
};
let suggests = match local_node {
Some(l) => l.suggests.clone(),
None => node.suggestions.as_deref().and_then(provider),
};
// The server's providers, as the client knows them
// (ArgumentNodeStub.build): its own custom ones arrive as `ask_server`.
let suggests = node.suggestions.as_deref().and_then(provider);
nodes[index(i)] = Some(Node {
kind: if i == root { NodeKind::Root } else { kind },
children: node.children.iter().filter_map(valid).map(index).collect(),
@@ -104,10 +103,10 @@ pub fn from_packet(packet: &Commands, local: &Dispatcher) -> Dispatcher {
d
}
/// SuggestionProviders by id (`ask_server` asks the server; the client's
/// own argument suggestions stand in for it).
/// SuggestionProviders by id (`SuggestionProviders.getProvider`).
fn provider(id: &str) -> Option<Suggests> {
match id {
"minecraft:ask_server" => Some(Suggests::AskServer),
"minecraft:summonable_entities" => Some(Suggests::SummonableEntities),
_ => None,
}
+17
View File
@@ -533,6 +533,23 @@ impl Game<'_> {
}
}
}
/// The server's completions for an `ask_server` request
/// (ClientPacketListener.handleCommandSuggestions).
pub(super) fn chat_server_suggestions(
&mut self,
id: i32,
range: (usize, usize),
list: Vec<(String, Option<String>)>,
) {
let m = Measure(&self.atlas.font);
let c = Commands {
dispatcher: chat_tree(&self.remote, &self.mods),
registries: &self.ui.registries,
};
if let Some(screen) = self.ui.chat_screen.as_mut() {
screen.server_suggestions(&m, &c, id, range, list);
}
}
/// Text typed into the chat box (control socket `chat`).
pub(super) fn chat_type(&mut self, text: &str) {
let m = Measure(&self.atlas.font);
+55
View File
@@ -558,8 +558,58 @@ impl Game<'_> {
break;
}
}
self.send_suggestion_request();
Ok(())
}
/// ClientSuggestionProvider.customSuggestion: the chat's completion
/// request for an `ask_server` node goes to the server.
fn send_suggestion_request(&mut self) {
if self.remote.is_none() {
return;
}
let Some((id, command)) = self.ui.chat_screen.as_mut().and_then(|s| s.take_request())
else {
return;
};
let mut w = horizon_protocol::buf::Writer::new();
w.varint(id);
w.string(&command);
self.send(S::Unknown(
horizon_protocol::ids::play::serverbound::COMMAND_SUGGESTION,
w.data,
));
}
/// ClientboundCommandSuggestionsPacket: id, range start and length, then
/// each suggestion's text and optional tooltip.
fn handle_command_suggestions(&mut self, data: &[u8]) {
let lang = self
.remote
.as_ref()
.map(|r| r.lang.clone())
.unwrap_or_default();
let mut r = horizon_protocol::buf::Reader::new(data);
let decoded = (|| {
let id = r.varint()?;
let start = r.varint()?;
let length = r.varint()?;
let n = r.count(usize::MAX)?;
let mut list = Vec::with_capacity(n.min(1000));
for _ in 0..n {
let text = r.string(32767)?;
let tooltip = if r.bool()? {
Some(plain(&r.nbt()?, &lang))
} else {
None
};
list.push((text, tooltip));
}
horizon_protocol::Result::Ok((id, start, length, list))
})();
if let Ok((id, start, length, list)) = decoded {
let range = (start.max(0) as usize, length.max(0) as usize);
self.chat_server_suggestions(id, range, list);
}
}
fn set_registries(&mut self, registries: Arc<Dynamic>) {
let biomes: Vec<u16> = registries
.registries
@@ -1641,6 +1691,11 @@ impl Game<'_> {
self.capture(true);
}
}
C::Unknown(id, data)
if id == horizon_protocol::ids::play::clientbound::COMMAND_SUGGESTIONS =>
{
self.handle_command_suggestions(&data);
}
C::Commands(p) => {
let tree = horizon_client::command::network::from_packet(
&p,
+19 -1
View File
@@ -732,11 +732,29 @@ def check_commands(host, guest, out):
screen = guest('state').get('screen')
guest('command', command='gamemode survival')
guest.wait(10)
# A node the tree marks ask_server (a bossbar id): the guest asks the
# server, which completes it from its own bossbars.
host('command', command='bossbar add pt6:check "Check"')
host.wait(5)
guest.raw('key', 'slash', 'tap')
guest.wait(3)
guest.raw('type', 'bossbar get pt')
guest.wait(10)
guest.raw('key', 'tab', 'tap')
guest.wait(2)
asked = chat_input(guest)
for _ in range(3):
if guest('screen').get('screen') != 'chat':
break
guest.raw('key', 'esc', 'tap')
guest.wait(3)
host('command', command='bossbar remove pt6:check')
assert literal == '/gamemode', f'Tab after /gamem: {literal!r}'
assert argument == '/gamemode creative', f'Tab after /gamemode cr: {argument!r}'
assert mode == 'creative', f'the completed command did not run: {mode}'
assert screen in (None, 'playing'), f'the chat did not close: {screen}'
return {'literal': literal, 'argument': argument, 'mode': mode}
assert asked == '/bossbar get pt6:check', f'Tab after /bossbar get pt: {asked!r}'
return {'literal': literal, 'argument': argument, 'mode': mode, 'ask_server': asked}
def centre(rect):