From a950a046aeabd47dc1afc9c3d06b08754ac314d1 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 16 Oct 2026 11:50:00 +0200 Subject: [PATCH] World Options: Edit Game Rules (InWorldGameRulesScreen) The rules by category under a search box, a switch or number box each, with vanilla's tooltip, number validation (Brigadier readInt and the rule's range, red text, Done held) and ConfirmScreen before discarding. Done sets the changed rules and tells the player, as handleSetGameRule does. The button follows the commands the player has, as updateButton. The control socket's `type` now reaches World Options' boxes. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/game.rs | 1 + crates/horizon-client/src/game/control.rs | 5 +- .../src/game/game_rules_screen.rs | 593 ++++++++++++++++++ crates/horizon-client/src/game/lan_screen.rs | 131 +++- 4 files changed, 716 insertions(+), 14 deletions(-) create mode 100644 crates/horizon-client/src/game/game_rules_screen.rs diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index dc9dd3a8f..cd12b8132 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -48,6 +48,7 @@ mod frames; mod friends; mod functions; mod game_mode; +mod game_rules_screen; mod gamemode_switcher; mod ghasts; mod golems; diff --git a/crates/horizon-client/src/game/control.rs b/crates/horizon-client/src/game/control.rs index 11fa9571e..7d8de6e2f 100644 --- a/crates/horizon-client/src/game/control.rs +++ b/crates/horizon-client/src/game/control.rs @@ -428,6 +428,9 @@ impl Game<'_> { Screen::Chat => self.chat_type(text), Screen::CommandBlock => self.command_block_type(text), Screen::Options => self.ui.options.type_text(&self.res.atlas, text), + // The port, or the game rules' search and number boxes. + Screen::WorldOptions if text == "\\b" => self.world_options_text(None), + Screen::WorldOptions => self.world_options_text(Some(text)), Screen::Inventory if self.recipe_search_focused() => { self.recipe_text(Some(text), false) } @@ -437,7 +440,7 @@ impl Game<'_> { } _ => { return Err( - "type needs the chat screen (key t tap), the language search or the creative search".into(), + "type needs the chat screen (key t tap), the language search, the creative search or World Options".into(), ); } } diff --git a/crates/horizon-client/src/game/game_rules_screen.rs b/crates/horizon-client/src/game/game_rules_screen.rs new file mode 100644 index 000000000..d99a7ab5b --- /dev/null +++ b/crates/horizon-client/src/game/game_rules_screen.rs @@ -0,0 +1,593 @@ +//! InWorldGameRulesScreen (AbstractGameRulesScreen), opened from World +//! Options: the rules by category under a search box, a switch or a number +//! box each, and Done sending the changed ones (ServerboundSetGameRulePacket). +//! Leaving with changes asks first (ConfirmScreen). +use horizon_client::{ + font::Font, + gamerules::{self, GameRules, RULES, Rule, Value}, + hud::{HudAtlas, HudBatch}, + lang, + text::{Style, Text, named_color}, + ui::{self, EditBox}, +}; + +/// HeaderAndFooterLayout(12 + 9 + 15, 33): the title over the search box. +const HEADER: f32 = 36.0; +const FOOTER: f32 = 33.0; +/// RuleList: 24 pixel entries in AbstractSelectionList's 220 pixel rows. +const ROW: f32 = 24.0; +const ROW_WIDTH: f32 = 220.0; +const SEARCH_WIDTH: f32 = 200.0; +/// EditBox text colours (`hud::rgba` order, ABGR): IntegerRuleEntry's valid +/// (-2039584) and invalid (-65536). +const VALID: u32 = 0xFFE0_E0E0; +const INVALID: u32 = 0xFF00_00FF; + +#[derive(Clone, Copy)] +enum Row { + Category(&'static str), + Rule(&'static Rule), +} + +/// What a click or Escape asks of World Options. +#[derive(Debug, PartialEq)] +pub(super) enum Exit { + /// Done: the rules that changed. + Apply(Vec<(&'static str, Value)>), + /// Cancel, or discarding the changes. + Discard, +} + +pub(super) struct RulesScreen { + search: EditBox, + values: GameRules, + initial: GameRules, + /// IntegerRuleEntry's boxes, by rule. + numbers: Vec<(&'static str, EditBox)>, + scroll: f32, + /// ConfirmScreen "Game Rule Changes" in its place. + confirm: bool, +} + +fn name_key(r: &Rule) -> String { + format!("gamerule.minecraft.{}", r.name) +} +fn category_key(category: &str) -> String { + format!("gamerule.category.minecraft.{category}") +} +/// GameRule.deserialize of an integer rule: Brigadier's readInt (digits, +/// '.' and '-' only, nothing after), then the rule's range. +fn parse(r: &Rule, s: &str) -> Option { + let number = !s.is_empty() + && s.chars() + .all(|c| c.is_ascii_digit() || c == '-' || c == '.'); + number + .then(|| s.parse::().ok()) + .flatten() + .filter(|v| (r.min..=r.max).contains(v)) +} +fn widest(font: &Font, lines: &[Text]) -> f32 { + lines.iter().map(|l| font.width_text(l)).fold(0.0, f32::max) +} +fn lines(font: &Font, t: &Text, width: f32) -> Vec { + font.split_lines(t, width) + .into_iter() + .map(|(line, _)| line) + .collect() +} +fn row_left(w: f32) -> f32 { + (w / 2.0).trunc() - ROW_WIDTH / 2.0 +} +/// A rule's switch or box: 44 by 20, 45 from the entry content's right. +fn control_x(w: f32) -> f32 { + row_left(w) + 2.0 + (ROW_WIDTH - 4.0) - 45.0 +} +/// The header's LinearLayout (title, 4, search box) centred in its 36 pixels. +fn search_at(w: f32) -> (f32, f32) { + (((w - SEARCH_WIDTH) / 2.0).trunc(), 4.0 + 9.0 + 4.0) +} +/// The footer's Done and Cancel, 150 wide and 8 apart. +fn footer(w: f32, h: f32) -> [(f32, f32); 2] { + let x = ((w - 308.0) / 2.0).trunc(); + [(x, h - FOOTER + 6.0), (x + 158.0, h - FOOTER + 6.0)] +} +fn yellow() -> u32 { + named_color("yellow").unwrap_or(0xFFFF55) +} + +/// ConfirmScreen: the title, the message (at most `width - 50` wide), and +/// Yes / No 16 below, 4 apart, all centred. +struct Confirm { + lines: Vec<(Text, f32, f32)>, + buttons: [(f32, f32); 2], +} +impl Confirm { + fn new(font: &Font, (w, h): (f32, f32)) -> Self { + let title = Text::translate("editGamerule.inGame.discardChanges.title", &[]); + let message = Text::translate("editGamerule.inGame.discardChanges.message", &[]); + let message: Vec = lines(font, &message, w - 50.0) + .into_iter() + .take(15) + .collect(); + let (tw, mw) = (font.width_text(&title), widest(font, &message)); + let mh = 9.0 * message.len() as f32; + let col = tw.max(mw).max(304.0); + let total = 9.0 + 8.0 + mh + 8.0 + 36.0; + let (lx, ly) = (((w - col) / 2.0).trunc(), ((h - total) / 2.0).trunc()); + let cell = |cw: f32| lx + ((col - cw) / 2.0).trunc(); + let mid = cell(mw) + (mw / 2.0).trunc(); + let mut out = vec![(title, cell(tw), ly)]; + for (i, line) in message.into_iter().enumerate() { + let x = mid - (font.width_text(&line) / 2.0).trunc(); + out.push((line, x, ly + 17.0 + 9.0 * i as f32)); + } + let (bx, by) = (cell(304.0), ly + 9.0 + 8.0 + mh + 8.0 + 16.0); + Self { + lines: out, + buttons: [(bx, by), (bx + 154.0, by)], + } + } +} + +impl RulesScreen { + pub(super) fn new(rules: &GameRules) -> Self { + // setInitialFocus: the search box. + let search = EditBox::new(0.0, 0.0, SEARCH_WIDTH, 15.0); + let numbers = RULES + .iter() + .filter(|r| matches!(r.default, Value::Int(_))) + .map(|r| { + let mut b = EditBox::new(0.0, 0.0, 44.0, 20.0); + b.focused = false; + b.set_value(&rules.int(r.name).to_string()); + b.text_color = VALID; + (r.name, b) + }) + .collect(); + Self { + search, + values: rules.clone(), + initial: rules.clone(), + numbers, + scroll: 0.0, + confirm: false, + } + } + + /// RuleList.populateChildren: the rules matching the search (id, name, + /// category or description), by category, each sorted by description id. + fn rows(&self) -> Vec { + let filter = self.search.value.to_lowercase(); + let has = |s: &str| s.to_lowercase().contains(&filter); + let mut categories: Vec<(&'static str, Vec<&'static Rule>)> = Vec::new(); + for r in RULES { + let key = name_key(r); + let description = format!("{key}.description"); + let matches = has(r.name) + || has(&lang::get(&key)) + || has(&lang::get(&category_key(r.category))) + || (lang::has(&description) && has(&lang::get(&description))); + if !matches { + continue; + } + match categories.iter_mut().find(|(c, _)| *c == r.category) { + Some((_, rules)) => rules.push(r), + None => categories.push((r.category, vec![r])), + } + } + // By the categories' ids, then the rules' description ids. + categories.sort_by_key(|(c, _)| *c); + categories + .into_iter() + .flat_map(|(c, mut rules)| { + rules.sort_by_key(|r| name_key(r)); + std::iter::once(Row::Category(c)).chain(rules.into_iter().map(Row::Rule)) + }) + .collect() + } + fn max_scroll(rows: usize, h: f32) -> f32 { + (ROW * rows as f32 + 4.0 - (h - HEADER - FOOTER)).max(0.0) + } + /// Entry `i`'s top: 2 under the list's top, less the scroll. + fn row_top(&self, i: usize) -> f32 { + HEADER + 2.0 - self.scroll.trunc() + ROW * i as f32 + } + /// getEntryAtPosition: the row under the pointer, inside the list. + fn hovered(&self, rows: usize, (x, y): (f32, f32), (w, h): (f32, f32)) -> Option { + let left = row_left(w); + let inside = y >= HEADER && y < h - FOOTER && x >= left && x < left + ROW_WIDTH; + let i = ((y - self.row_top(0)) / ROW).floor(); + (inside && i >= 0.0 && (i as usize) < rows).then_some(i as usize) + } + fn number(&mut self, name: &str) -> Option<&mut EditBox> { + self.numbers + .iter_mut() + .find(|(n, _)| *n == name) + .map(|(_, b)| b) + } + /// An invalid number disables Done (markInvalid). + fn invalid(&self) -> bool { + self.numbers + .iter() + .any(|(name, b)| gamerules::rule(name).is_none_or(|r| parse(r, &b.value).is_none())) + } + fn changes(&self) -> Vec<(&'static str, Value)> { + RULES + .iter() + .filter_map(|r| { + let value = self.values.get(r.name)?; + (Some(value) != self.initial.get(r.name)).then_some((r.name, value)) + }) + .collect() + } + /// InWorldGameRulesScreen.onClose: pending changes ask first. + fn close(&mut self) -> Option { + if self.changes().is_empty() { + Some(Exit::Discard) + } else { + self.confirm = true; + None + } + } + /// Escape: ConfirmScreen answers no; the rules close. + pub(super) fn escape(&mut self) -> Option { + if self.confirm { + self.confirm = false; + None + } else { + self.close() + } + } + /// The mouse wheel (AbstractSelectionList: half an entry a step). + pub(super) fn wheel(&mut self, delta: f32, h: f32) { + if !self.confirm { + let max = Self::max_scroll(self.rows().len(), h); + self.scroll = (self.scroll - delta * ROW / 2.0).clamp(0.0, max); + } + } + fn focused(&mut self) -> Option<(Option<&'static str>, &mut EditBox)> { + if self.search.focused { + return Some((None, &mut self.search)); + } + self.numbers + .iter_mut() + .find(|(_, b)| b.focused) + .map(|(n, b)| (Some(*n), b)) + } + /// The focused box changed: the search filters again from the top; a + /// number sets its rule when valid (IntegerRuleEntry's responder). + fn edited(&mut self, rule: Option<&'static str>) { + let Some(name) = rule else { + self.scroll = 0.0; + return; + }; + let Some(r) = gamerules::rule(name) else { + return; + }; + let value = self.number(name).map(|b| parse(r, &b.value)); + if let Some(Some(v)) = value { + self.values.set(name, Value::Int(v)); + } + if let Some(b) = self.number(name) { + b.text_color = if matches!(value, Some(Some(_))) { + VALID + } else { + INVALID + }; + } + } + /// Run an edit on the focused box, then its responder. + pub(super) fn edit(&mut self, f: impl FnOnce(&mut EditBox)) { + let Some((rule, b)) = self.focused() else { + return; + }; + let before = b.value.clone(); + f(b); + if b.value != before { + self.edited(rule); + } + } + pub(super) fn typing(&self) -> bool { + !self.confirm && (self.search.focused || self.numbers.iter().any(|(_, b)| b.focused)) + } + + /// A left click; Some when the screen closes. + pub(super) fn click( + &mut self, + atlas: &HudAtlas, + cursor: (f32, f32), + size: (f32, f32), + ) -> Option { + let (w, h) = size; + let on = |x: f32, y: f32, bw: f32, bh: f32| ui::hovered(cursor, x, y, bw, bh); + if self.confirm { + let c = Confirm::new(&atlas.font, size); + let [(yx, yy), (nx, ny)] = c.buttons; + if on(yx, yy, 150.0, 20.0) { + return Some(Exit::Discard); + } + if on(nx, ny, 150.0, 20.0) { + self.confirm = false; + } + return None; + } + let [(dx, dy), (cx, cy)] = footer(w, h); + if on(dx, dy, 150.0, 20.0) && !self.invalid() { + return Some(Exit::Apply(self.changes())); + } + if on(cx, cy, 150.0, 20.0) { + return self.close(); + } + // A click moves the focus to the widget under it. + let (sx, sy) = search_at(w); + if on(sx, sy, SEARCH_WIDTH, 15.0) { + self.unfocus(); + self.search.focused = true; + self.search.reset_blink(); + self.search.click(atlas, cursor.0, false, false); + return None; + } + let rows = self.rows(); + let i = self.hovered(rows.len(), cursor, size)?; + let Row::Rule(r) = rows[i] else { + return None; + }; + if !on(control_x(w), self.row_top(i) + 2.0, 44.0, 20.0) { + return None; + } + self.unfocus(); + match r.default { + Value::Bool(_) => { + let on = self.values.bool(r.name); + self.values.set(r.name, Value::Bool(!on)); + } + Value::Int(_) => { + if let Some(b) = self.number(r.name) { + b.focused = true; + b.reset_blink(); + b.click(atlas, cursor.0, false, false); + } + } + } + None + } + fn unfocus(&mut self) { + self.search.focused = false; + for (_, b) in &mut self.numbers { + b.focused = false; + } + } + /// Whether a click lands on a button (for its sound). + pub(super) fn clicks_button( + &self, + atlas: &HudAtlas, + cursor: (f32, f32), + size: (f32, f32), + ) -> bool { + let (w, h) = size; + let on = |(x, y): (f32, f32)| ui::hovered(cursor, x, y, 150.0, 20.0); + if self.confirm { + return Confirm::new(&atlas.font, size).buttons.into_iter().any(on); + } + let [done, cancel] = footer(w, h); + if (on(done) && !self.invalid()) || on(cancel) { + return true; + } + let rows = self.rows(); + self.hovered(rows.len(), cursor, size).is_some_and(|i| { + matches!(rows[i], Row::Rule(r) if matches!(r.default, Value::Bool(_))) + && ui::hovered(cursor, control_x(w), self.row_top(i) + 2.0, 44.0, 20.0) + }) + } + + pub(super) fn draw(&mut self, batch: &mut HudBatch, atlas: &HudAtlas, cursor: (f32, f32)) { + let (w, h) = (batch.width, batch.height); + ui::menu_background(batch, atlas, 0.0, 0.0, w, h, true); + if self.confirm { + let c = Confirm::new(&atlas.font, (w, h)); + for (line, x, y) in &c.lines { + batch.text_styled(atlas, line, *x, *y, u32::MAX, true); + } + for ((bx, by), key) in c.buttons.into_iter().zip(["gui.yes", "gui.no"]) { + let hover = ui::hovered(cursor, bx, by, 150.0, 20.0); + let label = Text::translate(key, &[]); + ui::button(batch, atlas, bx, by, 150.0, 20.0, &label, true, hover); + } + return; + } + let rows = self.rows(); + self.scroll = self.scroll.clamp(0.0, Self::max_scroll(rows.len(), h)); + // RuleList: the in-world list background, its entries clipped to it, + // then the separators and scrollbar. + ui::list_background(batch, atlas, HEADER, h - FOOTER, true); + let first = batch.vertices.len(); + let hovered = self.hovered(rows.len(), cursor, (w, h)); + let (left, x) = (row_left(w), control_x(w)); + for (i, row) in rows.iter().enumerate() { + let top = self.row_top(i); + if top + ROW < HEADER || top > h - FOOTER { + continue; + } + let (cx, cy) = (left + 2.0, top + 2.0); + match *row { + Row::Category(c) => { + // A FocusableTextWidget padded by 4, centred in the entry. + let label = Text::translate(&category_key(c), &[]) + .bold() + .underlined() + .with_color(yellow()); + let lw = atlas.font.width_text(&label); + let mid = cx + (ROW_WIDTH - 4.0) / 2.0; + let lx = mid - (lw / 2.0).trunc(); + batch.text_styled(atlas, &label, lx, cy + 10.0 - 8.0 + 4.0, u32::MAX, true); + } + Row::Rule(r) => { + let name = lines(&atlas.font, &Text::translate(&name_key(r), &[]), 170.0); + match name.as_slice() { + [one] => { + batch.text_styled(atlas, one, cx, cy + 5.0, u32::MAX, true); + } + [one, two, ..] => { + batch.text_styled(atlas, one, cx, cy, u32::MAX, true); + batch.text_styled(atlas, two, cx, cy + 10.0, u32::MAX, true); + } + [] => {} + } + let hover = hovered == Some(i) && ui::hovered(cursor, x, cy, 44.0, 20.0); + match r.default { + Value::Bool(_) => { + let key = if self.values.bool(r.name) { + "options.on" + } else { + "options.off" + }; + let label = Text::translate(key, &[]); + ui::button(batch, atlas, x, cy, 44.0, 20.0, &label, true, hover); + } + Value::Int(_) => { + if let Some(b) = self.number(r.name) { + b.x = x; + b.y = cy; + b.draw(batch, atlas, None); + } + } + } + } + } + } + batch.clip_since(first, 0.0, HEADER, w, h - FOOTER); + ui::separators(batch, atlas, HEADER, h - FOOTER, true); + let content = ROW * rows.len() as f32 + 4.0; + let bar_x = left + ROW_WIDTH + 6.0 + 2.0; + ui::scrollbar( + batch, + atlas, + bar_x, + HEADER, + h - FOOTER, + content, + self.scroll.trunc(), + ); + // The header: the title centred over the search box. + let title = Text::translate("editGamerule.title", &[]); + let tw = atlas.font.width_text(&title); + let (sx, sy) = search_at(w); + let lw = tw.max(SEARCH_WIDTH); + let lx = ((w - lw) / 2.0).trunc(); + batch.text_styled( + atlas, + &title, + lx + ((lw - tw) / 2.0).trunc(), + 4.0, + u32::MAX, + true, + ); + self.search.x = sx; + self.search.y = sy; + self.search.draw(batch, atlas, None); + if self.search.value.is_empty() && !self.search.focused { + // EditBox.SEARCH_HINT_STYLE: gray and italic. + let hint = Text::translate("gui.game_rule.search", &[]).with_style(&Style { + color: named_color("gray"), + italic: Some(true), + ..Style::default() + }); + let (hx, hy) = (self.search.text_x(), self.search.text_y()); + batch.text_styled(atlas, &hint, hx, hy, u32::MAX, true); + } + let invalid = self.invalid(); + for ((bx, by), (key, active)) in footer(w, h) + .into_iter() + .zip([("gui.done", !invalid), ("gui.cancel", true)]) + { + let hover = active && ui::hovered(cursor, bx, by, 150.0, 20.0); + let label = Text::translate(key, &[]); + ui::button(batch, atlas, bx, by, 150.0, 20.0, &label, active, hover); + } + // The hovered rule's tooltip: its id, description and default. + if let Some(Row::Rule(r)) = hovered.map(|i| rows[i]) { + let mut tip = vec![Text::literal(r.name).with_color(yellow())]; + let description = format!("{}.description", name_key(r)); + if lang::has(&description) { + tip.extend(lines( + &atlas.font, + &Text::translate(&description, &[]), + 150.0, + )); + } + let gray = named_color("gray").unwrap_or(0xAAAAAA); + tip.push( + Text::translate( + "editGamerule.default", + &[Text::literal(r.default.to_string())], + ) + .with_color(gray), + ); + ui::tooltip(batch, atlas, &tip, cursor); + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn box_colours_are_vanillas() { + assert_eq!(VALID, horizon_client::hud::rgba(224, 224, 224, 255)); + assert_eq!(INVALID, horizon_client::hud::rgba(255, 0, 0, 255)); + } + + #[test] + fn numbers_parse_like_brigadier_within_the_rule() { + let r = gamerules::rule("max_snow_accumulation_height").unwrap(); + assert_eq!(parse(r, "8"), Some(8)); + assert_eq!(parse(r, "9"), None); + assert_eq!(parse(r, "-1"), None); + for s in ["", "+3", " 3", "3 ", "3.0", "x"] { + assert_eq!(parse(r, s), None, "{s:?}"); + } + let r = gamerules::rule("fire_spread_radius_around_player").unwrap(); + assert_eq!(parse(r, "-1"), Some(-1)); + } + + #[test] + fn rows_group_categories_and_rules_by_description_id() { + let s = RulesScreen::new(&GameRules::default()); + let rows = s.rows(); + assert_eq!(rows.len(), RULES.len() + 7); + assert!(matches!(rows[0], Row::Category("chat"))); + let categories: Vec<_> = rows + .iter() + .filter_map(|r| match r { + Row::Category(c) => Some(*c), + Row::Rule(_) => None, + }) + .collect(); + assert_eq!( + categories, + [ + "chat", "drops", "misc", "mobs", "player", "spawning", "updates" + ] + ); + } + + #[test] + fn edits_change_rules_and_bad_numbers_hold_done() { + let mut s = RulesScreen::new(&GameRules::default()); + assert!(s.changes().is_empty()); + s.unfocus(); + s.number("random_tick_speed").unwrap().focused = true; + s.edit(|b| b.set_value("10")); + assert_eq!(s.changes(), vec![("random_tick_speed", Value::Int(10))]); + s.edit(|b| b.set_value("ten")); + assert!(s.invalid()); + // The last valid value stays, as the responder left it. + assert_eq!(s.changes(), vec![("random_tick_speed", Value::Int(10))]); + // Leaving with changes asks; No returns, Yes discards. + assert_eq!(s.escape(), None); + assert!(s.confirm); + assert_eq!(s.escape(), None); + assert!(!s.confirm); + } +} diff --git a/crates/horizon-client/src/game/lan_screen.rs b/crates/horizon-client/src/game/lan_screen.rs index c3876c4f0..0081b1745 100644 --- a/crates/horizon-client/src/game/lan_screen.rs +++ b/crates/horizon-client/src/game/lan_screen.rs @@ -4,7 +4,11 @@ //! difficulty, LAN on/off with its port, command access for guests and //! forcing the game mode. Its difficulty lock asks first (PopupScreen), and //! Restrictions opens RestrictionsScreen. -use super::{Game, Screen, lan::LanSettings}; +use super::{ + Game, Screen, + game_rules_screen::{Exit, RulesScreen}, + lan::LanSettings, +}; use horizon_client::{ font::Font, hud::{HudBatch, rgba}, @@ -33,14 +37,18 @@ pub(super) struct WorldOptions { /// ScrollableLayout's scroll amount. scroll: f32, view: View, + /// InWorldGameRulesScreen, while it is open. + rules: Option, } /// The screen on show: the options, the lock's question over them, or the -/// RestrictionsScreen they opened (both return to the same options). +/// RestrictionsScreen or InWorldGameRulesScreen they opened (all return to +/// the same options). #[derive(Clone, Copy, Debug, PartialEq)] enum View { Options, LockQuestion, Restrictions, + GameRules, } #[derive(Clone, PartialEq)] struct Snapshot { @@ -83,7 +91,6 @@ enum Button { Difficulty, /// DifficultyButtons.lockButton (LockIconButton). Lock, - /// InWorldGameRulesScreen is not in Horizon yet. GameRules, Restrictions, Lan, @@ -229,7 +236,9 @@ impl WorldOptions { // DifficultyButtons.updateDifficultyButtonsState: the level's // lock or hardcore, not the wanted lock. Button::Difficulty | Button::Lock => !self.hardcore && !self.difficulty_locked, - Button::GameRules => false, + // updateButton from the player's permission: the Allow Commands + // switch leaves it (updatePermissionDependentButtons(.., false)). + Button::GameRules => !self.hardcore && self.initial.cheats, Button::Restrictions => true, Button::CommandAccess => self.lan && self.cheats, Button::Force => self.lan && !(self.guest_commands && self.cheats) && !self.hardcore, @@ -421,6 +430,7 @@ impl Game<'_> { locked: self.level.difficulty_locked || self.level.hardcore, scroll: 0.0, view: View::Options, + rules: None, initial: Snapshot { default_mode: 0, personal_mode: 0, @@ -444,14 +454,40 @@ impl Game<'_> { } /// Escape: the question and RestrictionsScreen return to the options - /// (their onClose), which close. + /// (their onClose), which close; the game rules ask first. pub(super) fn world_options_escape(&mut self) { match self.world_options.as_mut() { + Some(o) if o.view == View::GameRules => { + if let Some(exit) = o.rules.as_mut().and_then(RulesScreen::escape) { + self.close_game_rules(exit); + } + } Some(o) if o.view != View::Options => o.view = View::Options, _ => self.close_world_options(), } } + /// InWorldGameRulesScreen's exit, back to the options. Done sends the + /// changed rules (ServerboundSetGameRulePacket), which the server's + /// handleSetGameRule sets for a gamemaster and tells its operators. + fn close_game_rules(&mut self, exit: Exit) { + if let Some(o) = self.world_options.as_mut() { + o.view = View::Options; + o.rules = None; + } + let Exit::Apply(changes) = exit else { + return; + }; + if !self.allow_commands() || changes.is_empty() { + return; + } + for (name, value) in changes { + self.ui.rules.set(name, value); + self.system_message(Text::tr("commands.gamerule.set", &[&name, &value])); + } + self.sync_rules(); + } + pub(super) fn draw_world_options(&mut self, batch: &mut HudBatch) { let Some(mut o) = self.world_options.take() else { return; @@ -464,6 +500,11 @@ impl Game<'_> { self.draw_lock_question(&o, batch); } View::Restrictions => self.draw_restrictions(batch), + View::GameRules => { + if let Some(rules) = o.rules.as_mut() { + rules.draw(batch, &self.res.atlas, self.cursor); + } + } } self.world_options = Some(o); } @@ -639,12 +680,16 @@ impl Game<'_> { /// The mouse wheel over the screen (ScrollableLayout, 10 pixels a step). pub(super) fn world_options_scroll(&mut self, delta: f32) { let h = self.gui_size().1; - if let Some(o) = self - .world_options - .as_mut() - .filter(|o| o.view == View::Options) - { - o.scroll = (o.scroll - delta * 10.0).clamp(0.0, WorldOptions::max_scroll(h)); + match self.world_options.as_mut() { + Some(o) if o.view == View::Options => { + o.scroll = (o.scroll - delta * 10.0).clamp(0.0, WorldOptions::max_scroll(h)); + } + Some(o) => { + if let Some(rules) = o.rules.as_mut() { + rules.wheel(delta, h); + } + } + None => {} } } @@ -655,6 +700,20 @@ impl Game<'_> { let (w, h) = self.gui_size(); match o.view { View::Options => {} + View::GameRules => { + let atlas = &self.res.atlas; + let exit = o.rules.as_mut().and_then(|rules| { + if rules.clicks_button(atlas, self.cursor, (w, h)) { + self.audio.play_button_click(); + } + rules.click(atlas, self.cursor, (w, h)) + }); + self.world_options = Some(o); + if let Some(exit) = exit { + self.close_game_rules(exit); + } + return; + } View::LockQuestion => { let p = Popup::lock_question(&self.res.atlas.font, o.difficulty, (w, h)); let hit = p @@ -725,6 +784,10 @@ impl Game<'_> { Some(Button::Difficulty) => o.difficulty = (o.difficulty + 1) % 4, Some(Button::Lock) => o.locked = !o.locked, Some(Button::Restrictions) => o.view = View::Restrictions, + Some(Button::GameRules) => { + o.rules = Some(RulesScreen::new(&self.ui.rules)); + o.view = View::GameRules; + } Some(Button::Lan) => { o.lan = !o.lan; o.port.focused = false; @@ -739,7 +802,7 @@ impl Game<'_> { // A new lock asks first. Some(Button::Apply) if o.locked != o.initial.locked => o.view = View::LockQuestion, Some(Button::Apply) => return self.apply_and_close_world_options(o), - Some(Button::GameRules) | None => {} + None => {} } self.world_options = Some(o); } @@ -764,6 +827,21 @@ impl Game<'_> { let Some(o) = self.world_options.as_mut() else { return; }; + if let Some(rules) = o.rules.as_mut().filter(|r| r.typing()) { + match shortcut { + Some(shortcut) => rules.edit(|b| { + b.shortcut(shortcut, &mut self.clipboard); + }), + None => { + let mut handled = false; + rules.edit(|b| handled = b.key(key, ctrl, false)); + if !handled && !ctrl { + self.world_options_text(event.text.as_deref()); + } + } + } + return; + } if !o.port.focused || o.view != View::Options { return; } @@ -778,6 +856,25 @@ impl Game<'_> { /// Digits typed into the port field (the keyboard, or a controller's /// on-screen keyboard), and its backspace. pub(super) fn world_options_text(&mut self, text: Option<&str>) { + if let Some(rules) = self + .world_options + .as_mut() + .and_then(|o| o.rules.as_mut()) + .filter(|r| r.typing()) + { + match text { + Some(text) => { + let typed: String = text.chars().filter(|c| !c.is_control()).collect(); + if !typed.is_empty() { + rules.edit(|b| b.insert_text(&typed)); + } + } + None => rules.edit(|b| { + b.key(winit::keyboard::KeyCode::Backspace, false, false); + }), + } + return; + } let Some(o) = self.world_options.as_mut().filter(|o| o.port.focused) else { return; }; @@ -853,6 +950,7 @@ mod tests { locked: hardcore, scroll: 0.0, view: View::Options, + rules: None, initial: Snapshot { default_mode: 0, personal_mode: 0, @@ -901,8 +999,15 @@ mod tests { assert!(o.active(Button::DefaultMode) && o.active(Button::Difficulty)); assert!(!o.active(Button::CommandAccess) && !o.active(Button::Force)); assert!(!o.active(Button::Apply)); - let o = options(false, false); + assert!(o.active(Button::GameRules)); + let mut o = options(false, false); assert!(!o.active(Button::DefaultMode) && !o.active(Button::PersonalMode)); + // Game Rules follows the commands the player has, not the switch. + assert!(!o.active(Button::GameRules)); + o.cheats = true; + assert!(!o.active(Button::GameRules)); + let o = options(true, true); + assert!(!o.active(Button::GameRules)); let o = options(false, true); assert!(!o.active(Button::Cheats) && !o.active(Button::Difficulty)); assert!(!o.active(Button::Force));