From 7cfb90538e3675f7f3127a97be0646d1fc0de6e0 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 9 Oct 2026 14:06:43 +0200 Subject: [PATCH] WIP: options, timer, mouse (to be squashed) --- .../examples/game_loop_probe.rs | 263 +++++++ .../horizon-client/examples/options_probe.rs | 32 + crates/horizon-client/src/clock.rs | 337 ++++++-- crates/horizon-client/src/game.rs | 85 ++- crates/horizon-client/src/java_text.rs | 613 +++++++++++++++ crates/horizon-client/src/key_names.rs | 265 +++++++ crates/horizon-client/src/keybinds.rs | 26 + crates/horizon-client/src/keymapping.rs | 110 +++ crates/horizon-client/src/lib.rs | 7 + crates/horizon-client/src/mouse.rs | 283 +++++++ crates/horizon-client/src/options_file.rs | 717 ++++++++++++++++++ crates/horizon-client/src/options_fixes.rs | 319 ++++++++ crates/horizon-client/src/settings.rs | 435 +++++------ crates/horizon-client/src/window.rs | 226 ++++++ .../parity/VanillaGameLoopOracle.java | 377 +++++++++ .../parity/VanillaOptionsOracle.java | 63 ++ .../parity/VanillaOptionsTableExporter.java | 119 +++ tools/oracle_harness.py | 118 +++ tools/test_options_parity.py | 185 +++++ 19 files changed, 4268 insertions(+), 312 deletions(-) create mode 100644 crates/horizon-client/examples/game_loop_probe.rs create mode 100644 crates/horizon-client/examples/options_probe.rs create mode 100644 crates/horizon-client/src/java_text.rs create mode 100644 crates/horizon-client/src/key_names.rs create mode 100644 crates/horizon-client/src/keymapping.rs create mode 100644 crates/horizon-client/src/mouse.rs create mode 100644 crates/horizon-client/src/options_file.rs create mode 100644 crates/horizon-client/src/options_fixes.rs create mode 100644 crates/horizon-client/src/window.rs create mode 100644 mods/horizon/src/test/java/dev/horizonlab/parity/VanillaGameLoopOracle.java create mode 100644 mods/horizon/src/test/java/dev/horizonlab/parity/VanillaOptionsOracle.java create mode 100644 mods/horizon/src/test/java/dev/horizonlab/parity/VanillaOptionsTableExporter.java create mode 100644 tools/oracle_harness.py create mode 100644 tools/test_options_parity.py diff --git a/crates/horizon-client/examples/game_loop_probe.rs b/crates/horizon-client/examples/game_loop_probe.rs new file mode 100644 index 000000000..f73b63a93 --- /dev/null +++ b/crates/horizon-client/examples/game_loop_probe.rs @@ -0,0 +1,263 @@ +#![forbid(unsafe_code)] +//! Runs the JSON-lines scenarios of tools/test_game_loop_parity.py through the +//! Rust timer, tick-rate manager, window, mouse and key-mapping code. +use horizon_client::{ + Result, + clock::{ServerTickRateManager, Timer}, + keymapping::KeyState, + mouse::{LookOptions, MouseLook, Rotation}, + window::{self, FrameContext, InactivityFpsLimit}, +}; +use serde_json::Value; +use std::{ + fs::File, + io::{BufRead, BufReader, BufWriter, Write}, +}; + +fn fl(v: &Value) -> f32 { + f32::from_bits(u32::from_str_radix(v.as_str().unwrap(), 16).unwrap()) +} +fn db(v: &Value) -> f64 { + f64::from_bits(u64::from_str_radix(v.as_str().unwrap(), 16).unwrap()) +} +fn fb(v: f32) -> String { + format!("{:08x}", if v.is_nan() { 0x7fc0_0000 } else { v.to_bits() }) +} +fn dbs(v: f64) -> String { + format!( + "{:016x}", + if v.is_nan() { + 0x7ff8_0000_0000_0000 + } else { + v.to_bits() + } + ) +} +fn b(v: &Value) -> bool { + v.as_bool().unwrap() +} + +fn timer(c: &Value, out: &mut impl Write) -> Result<()> { + let mut timer = Timer::new(fl(&c["tps"]), c["start"].as_i64().unwrap()); + writeln!(out, "timer")?; + for op in c["ops"].as_array().unwrap() { + let name = op[0].as_str().unwrap(); + let mut result = String::new(); + match name { + "adv" => { + let mspt = if op[2].is_null() { 0.0 } else { fl(&op[2]) }; + let ticks = timer.advance_game_time(op[1].as_i64().unwrap(), |d| { + if mspt == 0.0 { d } else { java_max(d, mspt) } + }); + result = format!(" {ticks}"); + } + "real" => timer.advance_real_time(op[1].as_i64().unwrap()), + "pause" => timer.update_pause_state(b(&op[1])), + "frozen" => timer.update_frozen_state(b(&op[1])), + _ => panic!("{name}"), + } + writeln!( + out, + "{name}{result} {} {} {} {}", + fb(timer.game_time_delta_ticks()), + fb(timer.game_time_delta_partial_tick(false)), + fb(timer.game_time_delta_partial_tick(true)), + fb(timer.realtime_delta_ticks()) + )?; + } + Ok(()) +} + +/// Math.max(float, float). +fn java_max(a: f32, b: f32) -> f32 { + if a.is_nan() || b.is_nan() { + f32::NAN + } else if a == 0.0 && b == 0.0 { + f32::from_bits(a.to_bits() & b.to_bits()) + } else if a >= b { + a + } else { + b + } +} + +fn rate(c: &Value, out: &mut impl Write) -> Result<()> { + let mut m = ServerTickRateManager::default(); + writeln!(out, "rate")?; + for op in c["ops"].as_array().unwrap() { + let name = op[0].as_str().unwrap(); + let mut result = String::new(); + let mut report = None; + match name { + "rate" => m.set_tick_rate(fl(&op[1])), + "freeze" => m.base.set_frozen(b(&op[1])), + "step" => result = format!(" {}", m.step_game_if_paused(op[1].as_i64().unwrap() as i32)), + "stopstep" => result = format!(" {}", m.stop_stepping()), + "sprint" => result = format!(" {}", m.request_game_to_sprint(op[1].as_i64().unwrap() as i32)), + "check" => { + let (run, r) = m.check_should_sprint_this_tick(op[1].as_i64().unwrap()); + result = format!(" {run}"); + report = r; + } + "end" => m.end_tick_work(op[1].as_i64().unwrap()), + "stopsprint" => { + report = m.stop_sprinting(); + result = format!(" {}", report.is_some()); + } + "tick" => m.base.tick(), + _ => panic!("{name}"), + } + let tail = report.map_or(String::new(), |r| { + format!(" report {} {}", r.ticks_per_second, r.milliseconds_per_tick) + }); + writeln!( + out, + "{name}{result} | {} {} {} {} {} {} {} {}{tail}", + fb(m.base.tickrate()), + m.base.nanoseconds_per_tick(), + fb(m.base.milliseconds_per_tick()), + m.base.runs_normally(), + m.base.is_stepping_forward(), + m.base.frozen_ticks_to_run(), + m.base.is_frozen(), + m.is_sprinting() + )?; + } + Ok(()) +} + +fn scale(c: &Value, out: &mut impl Write) -> Result<()> { + let i = |k: &str| c[k].as_i64().unwrap() as i32; + let fbsize = [i("w"), i("h")]; + let scale = window::calculate_scale(fbsize, i("max"), b(&c["uni"])); + let [gw, gh] = window::gui_scaled_size(fbsize, scale); + writeln!( + out, + "scale {scale} {gw} {gh} {} {}", + dbs(window::scaled_pos(db(&c["x"]), gw, i("sw"))), + dbs(window::scaled_pos(db(&c["y"]), gh, i("sh"))) + )?; + Ok(()) +} + +fn limit(c: &Value, out: &mut impl Write) -> Result<()> { + let ctx = FrameContext { + inactivity: if b(&c["afk"]) { InactivityFpsLimit::Afk } else { InactivityFpsLimit::Minimized }, + iconified: b(&c["iconified"]), + focused: b(&c["focused"]), + exclusive_fullscreen: false, + now_ms: c["ago"].as_i64().unwrap(), + latest_input_ms: 0, + has_level: b(&c["level"]), + has_screen: b(&c["screen"]), + has_overlay: b(&c["overlay"]), + }; + let reason = window::throttle_reason(ctx); + let name = match reason { + window::ThrottleReason::None => "NONE", + window::ThrottleReason::WindowIconified => "WINDOW_ICONIFIED", + window::ThrottleReason::LongAfk => "LONG_AFK", + window::ThrottleReason::ShortAfk => "SHORT_AFK", + window::ThrottleReason::OutOfLevelMenu => "OUT_OF_LEVEL_MENU", + }; + writeln!( + out, + "limit {name} {} {}", + window::framerate_limit(c["opt"].as_i64().unwrap() as i32, ctx), + window::heavily_throttled(reason) + )?; + Ok(()) +} + +fn mouse(c: &Value, out: &mut impl Write) -> Result<()> { + let look = LookOptions { + sensitivity: db(&c["sens"]), + smooth_camera: b(&c["smooth"]), + scoping: b(&c["scoping"]), + invert_x: b(&c["ix"]), + invert_y: b(&c["iy"]), + }; + let (active, grabbed) = (b(&c["active"]), b(&c["grabbed"])); + let mut handler = MouseLook::default(); + let mut rotation = Rotation { x_rot: 0.0, y_rot: 0.0, x_rot_o: 0.0, y_rot_o: 0.0 }; + writeln!(out, "mouse")?; + for op in c["ops"].as_array().unwrap() { + match op[0].as_str().unwrap() { + "move" => handler.on_move(db(&op[1]), db(&op[2]), db(&op[3]), db(&op[4]), active, grabbed), + "ignore" => handler.set_ignore_first_move(), + "frame" => { + if let Some((xo, yo)) = handler.handle_accumulated_movement(db(&op[1]), active, grabbed, look) { + rotation.turn(xo, yo); + } + writeln!( + out, + "frame {} {} {} {}", + fb(rotation.x_rot), + fb(rotation.y_rot), + fb(rotation.x_rot_o), + fb(rotation.y_rot_o) + )?; + } + other => panic!("{other}"), + } + } + Ok(()) +} + +fn scroll(c: &Value, out: &mut impl Write) -> Result<()> { + let mut handler = MouseLook::default(); + let mut slot = c["slot"].as_i64().unwrap() as i32; + writeln!(out, "scroll")?; + for op in c["ops"].as_array().unwrap() { + if let Some((wheel, _)) = handler.on_scroll(db(&op[0]), db(&op[1]), b(&c["discrete"]), db(&c["sens"])) { + slot = horizon_client::mouse::ScrollWheelHandler::next_selection(f64::from(wheel), slot, 9); + } + writeln!(out, "{slot}")?; + } + Ok(()) +} + +fn key(c: &Value, out: &mut impl Write) -> Result<()> { + let mut state = if b(&c["toggle"]) { + KeyState::toggle(b(&c["restore"]), b(&c["keyboard"])) + } else { + KeyState::plain() + }; + let mut option = false; + writeln!(out, "key")?; + for op in c["ops"].as_array().unwrap() { + let name = op[0].as_str().unwrap(); + let mut result = String::new(); + match name { + "option" => option = b(&op[1]), + "down" => state.set_down(b(&op[1]), option), + "release" => state.release(option), + "restore" => result = format!(" {}", state.should_restore_state_on_screen_closed(option)), + "click" => state.click(), + "consume" => result = format!(" {}", state.consume_click()), + "ingame" => result = format!(" {}", state.should_set_on_ingame_focus(option)), + _ => panic!("{name}"), + } + writeln!(out, "{name}{result} {}", state.is_down)?; + } + Ok(()) +} + +fn main() -> Result<()> { + let args: Vec<_> = std::env::args().skip(1).collect(); + let mut out = BufWriter::new(File::create(&args[1])?); + for line in BufReader::new(File::open(&args[0])?).lines() { + let c: Value = serde_json::from_str(&line?)?; + match c["t"].as_str().unwrap() { + "timer" => timer(&c, &mut out)?, + "rate" => rate(&c, &mut out)?, + "scale" => scale(&c, &mut out)?, + "limit" => limit(&c, &mut out)?, + "mouse" => mouse(&c, &mut out)?, + "scroll" => scroll(&c, &mut out)?, + "key" => key(&c, &mut out)?, + other => panic!("{other}"), + } + } + Ok(()) +} diff --git a/crates/horizon-client/examples/options_probe.rs b/crates/horizon-client/examples/options_probe.rs new file mode 100644 index 000000000..1cdf8c8fb --- /dev/null +++ b/crates/horizon-client/examples/options_probe.rs @@ -0,0 +1,32 @@ +#![forbid(unsafe_code)] +//! Loads and saves option files like `Options.load`/`save`, for the +//! differential harness (tools/test_options_parity.py). +use horizon_client::{Result, keybinds, options_file::OptionsFile}; +use std::{fs, io::Write}; + +fn main() -> Result<()> { + let args: Vec<_> = std::env::args().skip(1).collect(); + let mut names: Vec<_> = fs::read_dir(&args[0])? + .map(|e| e.map(|e| e.path())) + .collect::>()?; + names.sort(); + let mut out = fs::File::create(&args[1])?; + let mut first = true; + for path in names { + let name = path.file_name().unwrap().to_string_lossy().into_owned(); + let file = if name == "absent.txt" { + OptionsFile::default() + } else { + OptionsFile::parse(&String::from_utf8_lossy(&fs::read(&path)?)) + }; + write!(out, "== {name}\n{}", file.serialize())?; + if first { + first = false; + writeln!(out, "== keys")?; + for (name, key, category) in keybinds::MAPPINGS { + writeln!(out, "{name} {key} {category} {}", keybinds::is_toggle(name))?; + } + } + } + Ok(()) +} diff --git a/crates/horizon-client/src/clock.rs b/crates/horizon-client/src/clock.rs index 874fec656..f5cd91f8e 100644 --- a/crates/horizon-client/src/clock.rs +++ b/crates/horizon-client/src/clock.rs @@ -1,63 +1,304 @@ -//! Fixed-rate development simulation driver. Rendering consumes elapsed time; -//! a per-frame work cap retains its backlog instead of dropping simulation time. -use std::time::Duration; +//! `DeltaTracker.Timer` and the tick-rate managers of 26.3: how real +//! milliseconds turn into game ticks, partial ticks and real-time deltas, and +//! the `/tick` freeze, step and sprint state. -pub const TICK: Duration = Duration::from_millis(50); -#[derive(Default)] -pub struct FixedStep { - pending: Duration, +/// `DeltaTracker.Timer`: float arithmetic on integer milliseconds, exactly as +/// the client does it. +#[derive(Clone, Debug)] +pub struct Timer { + delta_ticks: f32, + delta_tick_residual: f32, + realtime_delta_ticks: f32, + paused_delta_tick_residual: f32, + last_ms: i64, + last_ui_ms: i64, + ms_per_tick: f32, + paused: bool, + frozen: bool, } -impl FixedStep { - pub fn advance(&mut self, elapsed: Duration) -> u32 { - self.pending += elapsed; - let steps = (self.pending.as_nanos() / TICK.as_nanos()).min(10) as u32; - self.pending -= TICK * steps; - steps + +impl Timer { + pub fn new(ticks_per_second: f32, current_ms: i64) -> Self { + Self { + delta_ticks: 0.0, + delta_tick_residual: 0.0, + realtime_delta_ticks: 0.0, + paused_delta_tick_residual: 0.0, + last_ms: current_ms, + last_ui_ms: current_ms, + ms_per_tick: 1000.0 / ticks_per_second, + paused: false, + frozen: false, + } } - pub fn reset(&mut self) { - self.pending = Duration::ZERO; + + /// `advanceGameTime`: the whole ticks to run now. `target_mspt` maps the + /// default milliseconds per tick to the target in force (the tick-rate + /// manager's, when the level runs normally). The caller runs at most ten. + pub fn advance_game_time(&mut self, current_ms: i64, target_mspt: impl FnOnce(f32) -> f32) -> i32 { + self.delta_ticks = (current_ms - self.last_ms) as f32 / target_mspt(self.ms_per_tick); + self.last_ms = current_ms; + self.delta_tick_residual += self.delta_ticks; + let ticks = self.delta_tick_residual as i32; + self.delta_tick_residual -= ticks as f32; + ticks } - pub fn fraction(&self) -> f64 { - (self.pending.as_secs_f64() / TICK.as_secs_f64()).min(1.0) + + /// `advanceRealTime`. + pub fn advance_real_time(&mut self, current_ms: i64) { + self.realtime_delta_ticks = (current_ms - self.last_ui_ms) as f32 / self.ms_per_tick; + self.last_ui_ms = current_ms; + } + + /// `updatePauseState`. + pub fn update_pause_state(&mut self, pause: bool) { + if pause { + if !self.paused { + self.paused_delta_tick_residual = self.delta_tick_residual; + } + self.paused = true; + } else { + if self.paused { + self.delta_tick_residual = self.paused_delta_tick_residual; + } + self.paused = false; + } + } + + /// `updateFrozenState`. + pub fn update_frozen_state(&mut self, frozen: bool) { + self.frozen = frozen; + } + + pub fn game_time_delta_ticks(&self) -> f32 { + self.delta_ticks + } + + /// `getGameTimeDeltaPartialTick`. + pub fn game_time_delta_partial_tick(&self, ignore_frozen_game: bool) -> f32 { + if !ignore_frozen_game && self.frozen { + 1.0 + } else if self.paused { + self.paused_delta_tick_residual + } else { + self.delta_tick_residual + } + } + + /// `getRealtimeDeltaTicks`. + pub fn realtime_delta_ticks(&self) -> f32 { + if self.realtime_delta_ticks > 7.0 { + 0.5 + } else { + self.realtime_delta_ticks + } + } +} + +const NANOSECONDS_PER_SECOND: i64 = 1_000_000_000; +const NANOSECONDS_PER_MILLISECOND: i64 = 1_000_000; + +/// `TickRateManager`. +#[derive(Clone, Debug)] +pub struct TickRateManager { + tickrate: f32, + nanoseconds_per_tick: i64, + frozen_ticks_to_run: i32, + run_game_elements: bool, + is_frozen: bool, +} + +impl Default for TickRateManager { + fn default() -> Self { + Self { + tickrate: 20.0, + nanoseconds_per_tick: NANOSECONDS_PER_SECOND / 20, + frozen_ticks_to_run: 0, + run_game_elements: true, + is_frozen: false, + } + } +} + +impl TickRateManager { + /// `setTickRate` (`Math.max(rate, 1.0F)`, NaN propagates). + pub fn set_tick_rate(&mut self, rate: f32) { + self.tickrate = if rate.is_nan() || rate > 1.0 { rate } else { 1.0 }; + self.nanoseconds_per_tick = (NANOSECONDS_PER_SECOND as f64 / f64::from(self.tickrate)) as i64; + } + pub fn tickrate(&self) -> f32 { + self.tickrate + } + pub fn milliseconds_per_tick(&self) -> f32 { + self.nanoseconds_per_tick as f32 / NANOSECONDS_PER_MILLISECOND as f32 + } + pub fn nanoseconds_per_tick(&self) -> i64 { + self.nanoseconds_per_tick + } + pub fn runs_normally(&self) -> bool { + self.run_game_elements + } + pub fn is_stepping_forward(&self) -> bool { + self.frozen_ticks_to_run > 0 + } + pub fn set_frozen_ticks_to_run(&mut self, ticks: i32) { + self.frozen_ticks_to_run = ticks; + } + pub fn frozen_ticks_to_run(&self) -> i32 { + self.frozen_ticks_to_run + } + pub fn set_frozen(&mut self, frozen: bool) { + self.is_frozen = frozen; + } + pub fn is_frozen(&self) -> bool { + self.is_frozen + } + /// `tick`: decides whether game elements run this tick. + pub fn tick(&mut self) { + self.run_game_elements = !self.is_frozen || self.frozen_ticks_to_run > 0; + if self.frozen_ticks_to_run > 0 { + self.frozen_ticks_to_run -= 1; + } + } + /// `isEntityFrozen` for an entity that is not (and does not carry) a player. + pub fn is_entity_frozen(&self, is_player_or_carries_player: bool) -> bool { + !self.runs_normally() && !is_player_or_carries_player + } +} + +/// What `/tick sprint` reports when it ends. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct SprintReport { + pub ticks_per_second: i32, + pub milliseconds_per_tick: String, +} + +/// `ServerTickRateManager`: the freeze, step and sprint state kept by the +/// server (the broadcasts to clients are the caller's concern). +#[derive(Clone, Debug, Default)] +pub struct ServerTickRateManager { + pub base: TickRateManager, + remaining_sprint_ticks: i64, + sprint_tick_start_time: i64, + sprint_time_spend: i64, + scheduled_current_sprint_ticks: i64, + previous_is_frozen: bool, +} + +impl ServerTickRateManager { + pub fn is_sprinting(&self) -> bool { + self.scheduled_current_sprint_ticks > 0 + } + /// `stepGameIfPaused`. + pub fn step_game_if_paused(&mut self, ticks: i32) -> bool { + if !self.base.is_frozen() { + return false; + } + self.base.set_frozen_ticks_to_run(ticks); + true + } + /// `stopStepping`. + pub fn stop_stepping(&mut self) -> bool { + if self.base.frozen_ticks_to_run() > 0 { + self.base.set_frozen_ticks_to_run(0); + true + } else { + false + } + } + /// `stopSprinting`. + pub fn stop_sprinting(&mut self) -> Option { + if self.remaining_sprint_ticks > 0 { + Some(self.finish_tick_sprint()) + } else { + None + } + } + /// `requestGameToSprint`: true when an earlier sprint was interrupted. + pub fn request_game_to_sprint(&mut self, time: i32) -> bool { + let interrupted = self.remaining_sprint_ticks > 0; + self.sprint_time_spend = 0; + self.scheduled_current_sprint_ticks = i64::from(time); + self.remaining_sprint_ticks = i64::from(time); + self.previous_is_frozen = self.base.is_frozen(); + self.base.set_frozen(false); + interrupted + } + fn finish_tick_sprint(&mut self) -> SprintReport { + let completed_ticks = self.scheduled_current_sprint_ticks - self.remaining_sprint_ticks; + let milliseconds_to_complete = + (self.sprint_time_spend.max(1)) as f64 / NANOSECONDS_PER_MILLISECOND as f64; + let ticks_per_second = (1000.0 * completed_ticks as f64 / milliseconds_to_complete) as i32; + let per_tick = if completed_ticks == 0 { + f64::from(self.base.milliseconds_per_tick()) + } else { + milliseconds_to_complete / completed_ticks as f64 + }; + self.scheduled_current_sprint_ticks = 0; + self.sprint_time_spend = 0; + self.remaining_sprint_ticks = 0; + self.base.set_frozen(self.previous_is_frozen); + SprintReport { + ticks_per_second, + milliseconds_per_tick: crate::java_text::format_fixed2(per_tick), + } + } + /// `checkShouldSprintThisTick`: whether to run this tick without waiting, + /// plus the report when the sprint just finished. + pub fn check_should_sprint_this_tick(&mut self, now_ns: i64) -> (bool, Option) { + if !self.base.run_game_elements { + (false, None) + } else if self.remaining_sprint_ticks > 0 { + self.sprint_tick_start_time = now_ns; + self.remaining_sprint_ticks -= 1; + (true, None) + } else { + (false, Some(self.finish_tick_sprint())) + } + } + /// `endTickWork`. + pub fn end_tick_work(&mut self, now_ns: i64) { + self.sprint_time_spend += now_ns - self.sprint_tick_start_time; + } + /// `setTickRate`. + pub fn set_tick_rate(&mut self, rate: f32) { + self.base.set_tick_rate(rate); } } #[cfg(test)] mod tests { use super::*; + #[test] - fn render_schedules_preserve_ticks_and_stall_backlog() { - for schedule in [&[7, 13, 18, 12][..], &[50][..], &[1, 999, 2700, 300][..]] { - let mut clock = FixedStep::default(); - let mut elapsed = Duration::ZERO; - let mut ticks = 0; - for _ in 0..100 { - for &ms in schedule { - let frame = Duration::from_millis(ms); - elapsed += frame; - let count = clock.advance(frame); - assert!(count <= 10); - ticks += count; - } - } - loop { - let count = clock.advance(Duration::ZERO); - ticks += count; - if count == 0 { - break; - } - } - assert_eq!(u128::from(ticks), elapsed.as_nanos() / TICK.as_nanos()); - } + fn timer_carries_fractions_and_caps_nothing_itself() { + let mut t = Timer::new(20.0, 0); + assert_eq!(t.advance_game_time(49, |d| d), 0); + assert_eq!(t.advance_game_time(50, |d| d), 1); + assert_eq!(t.advance_game_time(1050, |d| d), 20); } #[test] - fn pause_discards_only_explicitly_reset_time() { - let mut clock = FixedStep::default(); - assert_eq!(clock.advance(Duration::from_millis(49)), 0); - assert_eq!(clock.advance(Duration::from_millis(1)), 1); - assert_eq!(clock.advance(Duration::from_millis(24)), 0); - clock.reset(); - assert_eq!(clock.advance(Duration::from_millis(26)), 0); - assert_eq!(clock.advance(Duration::from_millis(24)), 1); + fn pause_restores_the_residual() { + let mut t = Timer::new(20.0, 0); + t.advance_game_time(25, |d| d); + t.update_pause_state(true); + t.advance_game_time(1000, |d| d); + assert_eq!(t.game_time_delta_partial_tick(false), 0.5); + t.update_pause_state(false); + assert_eq!(t.game_time_delta_partial_tick(false), 0.5); + } + #[test] + fn frozen_step_runs_exactly_the_requested_ticks() { + let mut m = ServerTickRateManager::default(); + m.base.set_frozen(true); + m.base.tick(); + assert!(!m.base.runs_normally()); + assert!(m.step_game_if_paused(2)); + for _ in 0..2 { + m.base.tick(); + assert!(m.base.runs_normally()); + } + m.base.tick(); + assert!(!m.base.runs_normally()); } } diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index b8f4a8529..ab53005c5 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -72,7 +72,7 @@ use horizon_client::{ biome::Biomes, blocks::{BlockFacts, Fluid}, chunk::{HEIGHT, MIN_Y}, - clock::FixedStep, + clock::{ServerTickRateManager, Timer}, collisions, containers::{BlockEntity, Providers}, crafting::Recipes, @@ -472,7 +472,11 @@ struct Game<'a> { options: Options, player: Option, spawn: Option, - clock: FixedStep, + clock: Timer, + /// `/tick` freeze, step and sprint state (TickRateManager). + tick_rate: ServerTickRateManager, + /// Minecraft.pause: a single-player screen that pauses the game is open. + pause: bool, previous_position: Vec3, eye: f32, previous_eye: f32, @@ -2227,7 +2231,8 @@ impl Game<'_> { self.apply_equipment(); self.eye = 1.62; self.previous_eye = 1.62; - self.clock.reset(); + let now = self.started.elapsed().as_millis() as i64; + self.clock = Timer::new(20.0, now); Ok(()) } fn tick(&mut self) -> Result<()> { @@ -2235,15 +2240,21 @@ impl Game<'_> { return self.tick_remote(); } self.ticks += 1; - self.world.game_time += 1; - if self.ui.rules.bool("advance_weather") { - self.world.weather.tick(&mut self.world.random); + // TickRateManager: a frozen level only ticks players (and what they ride). + let frozen = !self.tick_rate.base.runs_normally(); + if !frozen { + self.world.game_time += 1; + if self.ui.rules.bool("advance_weather") { + self.world.weather.tick(&mut self.world.random); + } + self.tick_weather_effects(); } - self.tick_weather_effects(); if self.ticks.is_multiple_of(6000) { self.save_game()?; } - self.advance_clock(); + if !frozen { + self.advance_clock(); + } if self.use_delay > 0 { self.use_delay -= 1; } @@ -2448,31 +2459,37 @@ impl Game<'_> { self.tick_burning(); self.tick_using(); self.titles.tick(); - self.tick_paintings(); - self.tick_item_frames(); - self.tick_armor_stands(); - self.tick_boats(); - self.tick_carts(); - self.tick_thunder(); - self.tick_lecterns(); - self.tick_maps(); - self.tick_bolts(); - self.tick_fishing(); - self.tick_tridents(); - self.tick_rockets(); + if !frozen { + self.tick_paintings(); + self.tick_item_frames(); + self.tick_armor_stands(); + self.tick_boats(); + self.tick_carts(); + self.tick_thunder(); + self.tick_lecterns(); + self.tick_maps(); + self.tick_bolts(); + self.tick_fishing(); + self.tick_tridents(); + self.tick_rockets(); + } self.tick_mining()?; - self.tick_items(); - self.spawn_loaded_entities(); - self.tick_mobs()?; + if !frozen { + self.tick_items(); + self.spawn_loaded_entities(); + self.tick_mobs()?; + } self.tick_experience(); self.tick_hand(); self.tick_sleep(); self.tick_portal()?; self.tick_end()?; self.postprocess_chunks()?; - self.tick_blocks()?; - self.tick_falling()?; - self.tick_tnt()?; + if !frozen { + self.tick_blocks()?; + self.tick_falling()?; + self.tick_tnt()?; + } if let Some(p) = &self.player { // Player.aiStep bob and Entity.walkDist (0.6 per block). let (dx, dz) = ( @@ -2490,8 +2507,10 @@ impl Game<'_> { }; self.bob.1 += (target - self.bob.1) * 0.4; } - self.tick_block_entities()?; - self.tick_brewing_stands()?; + if !frozen { + self.tick_block_entities()?; + self.tick_brewing_stands()?; + } if let Some(r) = &self.renderer { let eye = self.player.as_ref().map(|p| { [ @@ -2502,7 +2521,9 @@ impl Game<'_> { }); self.res.block_entity_render.tick(r.block_entities(), eye); } - self.tick_particles(); + if !frozen { + self.tick_particles(); + } if self.right && self.use_delay == 0 && self.screen == Screen::Playing { self.use_item()?; self.use_delay = 4; @@ -6614,7 +6635,7 @@ impl Game<'_> { else { return Ok(false); }; - let alpha = self.clock.fraction(); + let alpha = f64::from(self.clock.game_time_delta_partial_tick(false)); let (camera, underwater, view_yaw, view_pitch) = match &self.player { Some(p) => { let (a, b) = (self.previous_position, p.position); @@ -7564,7 +7585,9 @@ pub fn run() -> Result<()> { options, player: None, spawn: None, - clock: FixedStep::default(), + clock: Timer::new(20.0, 0), + tick_rate: ServerTickRateManager::default(), + pause: false, previous_position: Vec3::ZERO, eye: 1.62, previous_eye: 1.62, diff --git a/crates/horizon-client/src/java_text.rs b/crates/horizon-client/src/java_text.rs new file mode 100644 index 000000000..25eecf67e --- /dev/null +++ b/crates/horizon-client/src/java_text.rs @@ -0,0 +1,613 @@ +//! Java text conventions the vanilla option files depend on: shortest-digit +//! `Double.toString`/`Float.toString`, Gson's HTML-safe string escaping and a +//! reader for Gson's lenient JSON (`JsonParser.parseString`). + +/// Digits and decimal exponent of the shortest round-trip form. +fn shortest(text: &str) -> (String, i32) { + // `{:e}` yields "d.ddde-5" or "de5". + let (mantissa, exponent) = text.split_once('e').unwrap_or((text, "0")); + let digits: String = mantissa.chars().filter(char::is_ascii_digit).collect(); + (digits, exponent.parse().unwrap_or(0)) +} + +fn render(negative: bool, digits: &str, exponent: i32) -> String { + let mut out = String::new(); + if negative { + out.push('-'); + } + let digits = if digits.is_empty() { "0" } else { digits }; + if (-3..7).contains(&exponent) { + if exponent >= 0 { + let int_len = exponent as usize + 1; + if digits.len() <= int_len { + out.push_str(digits); + out.extend(std::iter::repeat_n('0', int_len - digits.len())); + out.push_str(".0"); + } else { + out.push_str(&digits[..int_len]); + out.push('.'); + out.push_str(&digits[int_len..]); + } + } else { + out.push_str("0."); + out.extend(std::iter::repeat_n('0', (-exponent - 1) as usize)); + out.push_str(digits); + } + } else { + out.push_str(&digits[..1]); + out.push('.'); + if digits.len() > 1 { + out.push_str(&digits[1..]); + } else { + out.push('0'); + } + out.push('E'); + out.push_str(&exponent.to_string()); + } + out +} + +/// `Double.toString`. +pub fn double_to_string(value: f64) -> String { + if value.is_nan() { + return "NaN".into(); + } + if value.is_infinite() { + return if value < 0.0 { "-Infinity" } else { "Infinity" }.into(); + } + if value == 0.0 { + return if value.is_sign_negative() { + "-0.0" + } else { + "0.0" + } + .into(); + } + let (digits, exponent) = shortest(&format!("{:e}", value.abs())); + render(value < 0.0, &digits, exponent) +} + +/// `Float.toString`. +pub fn float_to_string(value: f32) -> String { + if value.is_nan() { + return "NaN".into(); + } + if value.is_infinite() { + return if value < 0.0 { "-Infinity" } else { "Infinity" }.into(); + } + if value == 0.0 { + return if value.is_sign_negative() { + "-0.0" + } else { + "0.0" + } + .into(); + } + let (digits, exponent) = shortest(&format!("{:e}", value.abs())); + render(value < 0.0, &digits, exponent) +} + +/// Gson's default (HTML-safe) JSON string literal. +pub fn gson_string(value: &str) -> String { + let mut out = String::from("\""); + for c in value.chars() { + match c { + '"' => out.push_str("\\\""), + '\\' => out.push_str("\\\\"), + '\n' => out.push_str("\\n"), + '\r' => out.push_str("\\r"), + '\t' => out.push_str("\\t"), + '\u{8}' => out.push_str("\\b"), + '\u{c}' => out.push_str("\\f"), + '<' | '>' | '&' | '=' | '\'' | '\u{2028}' | '\u{2029}' => { + out.push_str(&format!("\\u{:04x}", c as u32)); + } + c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)), + c => out.push(c), + } + } + out.push('"'); + out +} + +/// A parsed JSON element as Gson models it. +#[derive(Clone, Debug, PartialEq)] +pub enum Json { + Null, + Bool(bool), + /// The number's source text (`LazilyParsedNumber`). + Number(String), + String(String), + Array(Vec), + Object, +} + +impl Json { + /// `Number.intValue()` of a `LazilyParsedNumber`: `Integer.parseInt`, else + /// `BigDecimal.intValue()` (truncate, keep the low 32 bits). + pub fn int_value(text: &str) -> i32 { + let (negative, body) = match text.strip_prefix('-') { + Some(rest) => (true, rest), + None => (false, text), + }; + let (mantissa, exponent) = match body.split_once(['e', 'E']) { + Some((m, e)) => ( + m, + e.strip_prefix('+').unwrap_or(e).parse::().unwrap_or(0), + ), + None => (body, 0), + }; + let (int_part, fraction) = mantissa.split_once('.').unwrap_or((mantissa, "")); + let digits: Vec = int_part + .chars() + .chain(fraction.chars()) + .filter_map(|c| c.to_digit(10)) + .collect(); + // value = digits * 10^scale; truncating drops digits below the point. + let scale = exponent - fraction.len() as i64; + let keep = if scale >= 0 { + digits.len() + } else { + digits + .len() + .saturating_sub(scale.unsigned_abs().min(usize::MAX as u64) as usize) + }; + let mut v: u32 = 0; + for d in &digits[..keep] { + v = v.wrapping_mul(10).wrapping_add(*d); + } + if scale > 0 { + // v * 10^scale modulo 2^32 by repeated squaring. + let (mut base, mut power, mut e) = (10u32, 1u32, scale as u64); + while e > 0 { + if e & 1 == 1 { + power = power.wrapping_mul(base); + } + base = base.wrapping_mul(base); + e >>= 1; + } + v = v.wrapping_mul(power); + } + let v = v as i32; + if negative { v.wrapping_neg() } else { v } + } + /// `Number.doubleValue()`. + pub fn double_value(text: &str) -> f64 { + text.parse::().unwrap_or(0.0) + } +} + +/// A syntax error aborts the whole options load, as in vanilla. +#[derive(Debug)] +pub struct SyntaxError; + +struct Reader { + chars: Vec, + pos: usize, +} + +fn is_literal(c: char) -> bool { + !matches!( + c, + '/' | '\\' + | ';' + | '#' + | '=' + | '{' + | '}' + | '[' + | ']' + | ':' + | ',' + | ' ' + | '\t' + | '\u{c}' + | '\r' + | '\n' + ) +} + +impl Reader { + fn peek_char(&self) -> Option { + self.chars.get(self.pos).copied() + } + /// `nextNonWhitespace` with lenient comments; `None` at the end. + fn skip(&mut self) -> Result, SyntaxError> { + loop { + match self.peek_char() { + None => return Ok(None), + Some(' ' | '\t' | '\r' | '\n') => self.pos += 1, + Some('#') => self.line_comment(), + Some('/') => match self.chars.get(self.pos + 1) { + Some('/') => self.line_comment(), + Some('*') => { + self.pos += 2; + loop { + match (self.peek_char(), self.chars.get(self.pos + 1)) { + (Some('*'), Some('/')) => { + self.pos += 2; + break; + } + (Some(_), _) => self.pos += 1, + (None, _) => return Err(SyntaxError), + } + } + } + _ => return Ok(Some('/')), + }, + Some(c) => return Ok(Some(c)), + } + } + } + fn line_comment(&mut self) { + while let Some(c) = self.peek_char() { + self.pos += 1; + if c == '\n' || c == '\r' { + break; + } + } + } + fn quoted(&mut self, quote: char) -> Result { + self.pos += 1; + let mut out = String::new(); + loop { + let c = self.peek_char().ok_or(SyntaxError)?; + self.pos += 1; + if c == quote { + return Ok(out); + } + if c != '\\' { + out.push(c); + continue; + } + let e = self.peek_char().ok_or(SyntaxError)?; + self.pos += 1; + match e { + 'u' => { + let mut v = 0u32; + for _ in 0..4 { + let d = self.peek_char().ok_or(SyntaxError)?; + self.pos += 1; + v = v * 16 + d.to_digit(16).ok_or(SyntaxError)?; + } + // Lone surrogates cannot be represented; keep the replacement. + out.push(char::from_u32(v).unwrap_or('\u{fffd}')); + } + 't' => out.push('\t'), + 'b' => out.push('\u{8}'), + 'n' => out.push('\n'), + 'r' => out.push('\r'), + 'f' => out.push('\u{c}'), + '\n' | '\'' | '"' | '\\' | '/' => out.push(e), + _ => return Err(SyntaxError), + } + } + } + fn literal(&mut self) -> String { + let start = self.pos; + while self.peek_char().is_some_and(is_literal) { + self.pos += 1; + } + self.chars[start..self.pos].iter().collect() + } + /// JSON number grammar with Gson's leading-zero rule. + fn is_number(text: &str) -> bool { + let b: Vec = text.chars().collect(); + let mut i = 0; + if b.first() == Some(&'-') { + i += 1; + } + match b.get(i) { + Some('0') => { + i += 1; + } + Some(c) if c.is_ascii_digit() => { + while b.get(i).is_some_and(char::is_ascii_digit) { + i += 1; + } + } + _ => return false, + } + if b.get(i) == Some(&'.') { + i += 1; + if !b.get(i).is_some_and(char::is_ascii_digit) { + return false; + } + while b.get(i).is_some_and(char::is_ascii_digit) { + i += 1; + } + } + if matches!(b.get(i), Some('e' | 'E')) { + i += 1; + if matches!(b.get(i), Some('+' | '-')) { + i += 1; + } + if !b.get(i).is_some_and(char::is_ascii_digit) { + return false; + } + while b.get(i).is_some_and(char::is_ascii_digit) { + i += 1; + } + } + i == b.len() + } + fn keyword(text: &str, word: &str) -> bool { + text.len() == word.len() && text.eq_ignore_ascii_case(word) + } + fn value(&mut self) -> Result { + let c = self.skip()?.ok_or(SyntaxError)?; + match c { + '"' | '\'' => Ok(Json::String(self.quoted(c)?)), + '[' => { + self.pos += 1; + let mut items = Vec::new(); + loop { + match self.skip()?.ok_or(SyntaxError)? { + ']' => { + self.pos += 1; + // A trailing separator leaves an implicit null. + return Ok(Json::Array(items)); + } + ',' | ';' => { + self.pos += 1; + items.push(Json::Null); + continue; + } + _ => {} + } + items.push(self.value()?); + match self.skip()?.ok_or(SyntaxError)? { + ']' => { + self.pos += 1; + return Ok(Json::Array(items)); + } + ',' | ';' => self.pos += 1, + _ => return Err(SyntaxError), + } + } + } + '{' => { + self.pos += 1; + loop { + match self.skip()?.ok_or(SyntaxError)? { + '}' => { + self.pos += 1; + return Ok(Json::Object); + } + '"' | '\'' => { + let q = self.skip()?.ok_or(SyntaxError)?; + self.quoted(q)?; + } + c if is_literal(c) => { + self.literal(); + } + _ => return Err(SyntaxError), + } + match self.skip()?.ok_or(SyntaxError)? { + ':' => self.pos += 1, + '=' => { + self.pos += 1; + if self.peek_char() == Some('>') { + self.pos += 1; + } + } + _ => return Err(SyntaxError), + } + self.value()?; + match self.skip()?.ok_or(SyntaxError)? { + '}' => { + self.pos += 1; + return Ok(Json::Object); + } + ',' | ';' => self.pos += 1, + _ => return Err(SyntaxError), + } + } + } + ']' | '}' | ',' | ';' | ':' | '=' | '\\' | '/' => Err(SyntaxError), + _ => { + let text = self.literal(); + if text.is_empty() { + return Err(SyntaxError); + } + if Self::keyword(&text, "true") { + Ok(Json::Bool(true)) + } else if Self::keyword(&text, "false") { + Ok(Json::Bool(false)) + } else if Self::keyword(&text, "null") { + Ok(Json::Null) + } else if Self::is_number(&text) { + Ok(Json::Number(text)) + } else { + Ok(Json::String(text)) + } + } + } + } +} + +/// `JsonParser.parseString`: one lenient value and nothing after it. +pub fn parse_lenient(text: &str) -> Result { + let text = text.strip_prefix(")]}'\n").unwrap_or(text); + let mut reader = Reader { + chars: text.chars().collect(), + pos: 0, + }; + if reader.skip()?.is_none() { + return Ok(Json::Null); + } + let value = reader.value()?; + // The trailing check runs after Gson restored its legacy-strict mode: + // only whitespace may follow the value. + if value != Json::Null + && reader.chars[reader.pos..] + .iter() + .any(|c| !matches!(c, ' ' | '\t' | '\r' | '\n')) + { + return Err(SyntaxError); + } + Ok(value) +} + +impl Reader { + /// Next non-whitespace char in strict mode (comments are errors). + fn strict_skip(&mut self) -> Option { + while matches!(self.peek_char(), Some(' ' | '\t' | '\r' | '\n')) { + self.pos += 1; + } + self.peek_char() + } +} + +/// `Gson.getAdapter(List).read` on a strict `JsonReader` +/// (`GsonHelper.fromNullableJson`): `Ok(None)` for `null`, an error for +/// anything Gson rejects, including an empty document. +pub fn parse_strict_string_list(text: &str) -> Result>, SyntaxError> { + let mut r = Reader { + chars: text.chars().collect(), + pos: 0, + }; + match r.strict_skip().ok_or(SyntaxError)? { + 'n' => { + let word = r.literal(); + if word == "null" { + Ok(None) + } else { + Err(SyntaxError) + } + } + '[' => { + r.pos += 1; + let mut items = Vec::new(); + if r.strict_skip().ok_or(SyntaxError)? == ']' { + return Ok(Some(items)); + } + loop { + let c = r.strict_skip().ok_or(SyntaxError)?; + match c { + '"' => items.push(r.quoted('"')?), + '-' | '0'..='9' => { + let word = r.literal(); + if !Reader::is_number(&word) { + return Err(SyntaxError); + } + items.push(word); + } + 't' | 'f' | 'n' => { + let word = r.literal(); + match word.as_str() { + "true" | "false" => items.push(word), + "null" => {} + _ => return Err(SyntaxError), + } + } + _ => return Err(SyntaxError), + } + match r.strict_skip().ok_or(SyntaxError)? { + ',' => r.pos += 1, + ']' => return Ok(Some(items)), + _ => return Err(SyntaxError), + } + } + } + _ => Err(SyntaxError), + } +} + +/// `String.format(Locale.ROOT, "%.f", value)`: Java rounds the shortest +/// round-trip decimal expansion half-up (so 1.005 gives 1.01). +pub fn format_fixed(value: f64, decimals: usize) -> String { + if value.is_nan() { + return "NaN".into(); + } + if value.is_infinite() { + return if value < 0.0 { "-Infinity" } else { "Infinity" }.into(); + } + let negative = value.is_sign_negative(); + let (digits, exponent) = if value == 0.0 { + ("0".to_owned(), 0) + } else { + shortest(&format!("{:e}", value.abs())) + }; + let mut int_part: Vec = Vec::new(); + let mut frac: Vec = Vec::new(); + let d: Vec = digits.bytes().map(|b| b - b'0').collect(); + let point = exponent + 1; // digits before the decimal point + if point <= 0 { + int_part.push(0); + frac.extend(std::iter::repeat_n(0, (-point) as usize)); + frac.extend(&d); + } else { + let point = point as usize; + for i in 0..point { + int_part.push(d.get(i).copied().unwrap_or(0)); + } + if d.len() > point { + frac.extend(&d[point..]); + } + } + let round_up = frac.get(decimals).is_some_and(|&x| x >= 5); + frac.truncate(decimals); + frac.resize(decimals, 0); + if round_up { + let mut carry = true; + for x in frac.iter_mut().rev().chain(int_part.iter_mut().rev()) { + if !carry { + break; + } + if *x == 9 { + *x = 0; + } else { + *x += 1; + carry = false; + } + } + if carry { + int_part.insert(0, 1); + } + } + let mut out = String::new(); + if negative { + out.push('-'); + } + out.extend(int_part.iter().map(|&x| (b'0' + x) as char)); + if decimals > 0 { + out.push('.'); + out.extend(frac.iter().map(|&x| (b'0' + x) as char)); + } + out +} + +/// `%.2f`. +pub fn format_fixed2(value: f64) -> String { + format_fixed(value, 2) +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn java_number_text() { + assert_eq!(double_to_string(1.0), "1.0"); + assert_eq!(double_to_string(0.5), "0.5"); + assert_eq!(double_to_string(0.0001), "1.0E-4"); + assert_eq!(double_to_string(0.001), "0.001"); + assert_eq!(double_to_string(1234567.0), "1234567.0"); + assert_eq!(double_to_string(12345678.0), "1.2345678E7"); + assert_eq!(double_to_string(100.0), "100.0"); + assert_eq!(float_to_string(0.15), "0.15"); + assert_eq!(float_to_string(1.0e10), "1.0E10"); + assert_eq!(double_to_string(-2.5), "-2.5"); + } + #[test] + fn lenient_json() { + assert_eq!(parse_lenient("0.5").unwrap(), Json::Number("0.5".into())); + assert_eq!(parse_lenient("fast").unwrap(), Json::String("fast".into())); + assert_eq!(parse_lenient("TRUE").unwrap(), Json::Bool(true)); + assert_eq!(parse_lenient("007").unwrap(), Json::String("007".into())); + assert!(parse_lenient("1 2").is_err()); + assert!(parse_lenient("\"abc").is_err()); + assert_eq!(parse_lenient(" ").unwrap(), Json::Null); + assert_eq!(gson_string("a=b"), "\"a\\u003db\""); + } +} diff --git a/crates/horizon-client/src/key_names.rs b/crates/horizon-client/src/key_names.rs new file mode 100644 index 000000000..c6ba9d634 --- /dev/null +++ b/crates/horizon-client/src/key_names.rs @@ -0,0 +1,265 @@ +//! InputConstants key tables of 26.3 (SDL scancodes), generated from the +//! pinned client by `VanillaOptionsTableExporter`. + +/// Keyboard keys: (SDL scancode, key name). +pub const KEYBOARD: &[(i32, &str)] = &[ + (0, "key.keyboard.unknown"), + (4, "key.keyboard.a"), + (5, "key.keyboard.b"), + (6, "key.keyboard.c"), + (7, "key.keyboard.d"), + (8, "key.keyboard.e"), + (9, "key.keyboard.f"), + (10, "key.keyboard.g"), + (11, "key.keyboard.h"), + (12, "key.keyboard.i"), + (13, "key.keyboard.j"), + (14, "key.keyboard.k"), + (15, "key.keyboard.l"), + (16, "key.keyboard.m"), + (17, "key.keyboard.n"), + (18, "key.keyboard.o"), + (19, "key.keyboard.p"), + (20, "key.keyboard.q"), + (21, "key.keyboard.r"), + (22, "key.keyboard.s"), + (23, "key.keyboard.t"), + (24, "key.keyboard.u"), + (25, "key.keyboard.v"), + (26, "key.keyboard.w"), + (27, "key.keyboard.x"), + (28, "key.keyboard.y"), + (29, "key.keyboard.z"), + (30, "key.keyboard.1"), + (31, "key.keyboard.2"), + (32, "key.keyboard.3"), + (33, "key.keyboard.4"), + (34, "key.keyboard.5"), + (35, "key.keyboard.6"), + (36, "key.keyboard.7"), + (37, "key.keyboard.8"), + (38, "key.keyboard.9"), + (39, "key.keyboard.0"), + (40, "key.keyboard.enter"), + (41, "key.keyboard.escape"), + (42, "key.keyboard.backspace"), + (43, "key.keyboard.tab"), + (44, "key.keyboard.space"), + (45, "key.keyboard.minus"), + (46, "key.keyboard.equal"), + (47, "key.keyboard.left.bracket"), + (48, "key.keyboard.right.bracket"), + (49, "key.keyboard.backslash"), + (50, "key.keyboard.world.2"), + (51, "key.keyboard.semicolon"), + (52, "key.keyboard.apostrophe"), + (53, "key.keyboard.grave.accent"), + (54, "key.keyboard.comma"), + (55, "key.keyboard.period"), + (56, "key.keyboard.slash"), + (57, "key.keyboard.caps.lock"), + (58, "key.keyboard.f1"), + (59, "key.keyboard.f2"), + (60, "key.keyboard.f3"), + (61, "key.keyboard.f4"), + (62, "key.keyboard.f5"), + (63, "key.keyboard.f6"), + (64, "key.keyboard.f7"), + (65, "key.keyboard.f8"), + (66, "key.keyboard.f9"), + (67, "key.keyboard.f10"), + (68, "key.keyboard.f11"), + (69, "key.keyboard.f12"), + (70, "key.keyboard.print.screen"), + (71, "key.keyboard.scroll.lock"), + (72, "key.keyboard.pause"), + (73, "key.keyboard.insert"), + (74, "key.keyboard.home"), + (75, "key.keyboard.page.up"), + (76, "key.keyboard.delete"), + (77, "key.keyboard.end"), + (78, "key.keyboard.page.down"), + (79, "key.keyboard.right"), + (80, "key.keyboard.left"), + (81, "key.keyboard.down"), + (82, "key.keyboard.up"), + (83, "key.keyboard.num.lock"), + (84, "key.keyboard.keypad.divide"), + (85, "key.keyboard.keypad.multiply"), + (86, "key.keyboard.keypad.subtract"), + (87, "key.keyboard.keypad.add"), + (88, "key.keyboard.keypad.enter"), + (89, "key.keyboard.keypad.1"), + (90, "key.keyboard.keypad.2"), + (91, "key.keyboard.keypad.3"), + (92, "key.keyboard.keypad.4"), + (93, "key.keyboard.keypad.5"), + (94, "key.keyboard.keypad.6"), + (95, "key.keyboard.keypad.7"), + (96, "key.keyboard.keypad.8"), + (97, "key.keyboard.keypad.9"), + (98, "key.keyboard.keypad.0"), + (99, "key.keyboard.keypad.period"), + (100, "key.keyboard.world.1"), + (101, "key.keyboard.application"), + (102, "key.keyboard.power"), + (103, "key.keyboard.keypad.equal"), + (104, "key.keyboard.f13"), + (105, "key.keyboard.f14"), + (106, "key.keyboard.f15"), + (107, "key.keyboard.f16"), + (108, "key.keyboard.f17"), + (109, "key.keyboard.f18"), + (110, "key.keyboard.f19"), + (111, "key.keyboard.f20"), + (112, "key.keyboard.f21"), + (113, "key.keyboard.f22"), + (114, "key.keyboard.f23"), + (115, "key.keyboard.f24"), + (116, "key.keyboard.execute"), + (117, "key.keyboard.help"), + (118, "key.keyboard.menu"), + (119, "key.keyboard.select"), + (120, "key.keyboard.stop"), + (121, "key.keyboard.again"), + (122, "key.keyboard.undo"), + (123, "key.keyboard.cut"), + (124, "key.keyboard.copy"), + (125, "key.keyboard.paste"), + (126, "key.keyboard.find"), + (127, "key.keyboard.mute"), + (128, "key.keyboard.volume.up"), + (129, "key.keyboard.volume.down"), + (133, "key.keyboard.keypad.comma"), + (134, "key.keyboard.keypad.equals.as400"), + (135, "key.keyboard.international1"), + (136, "key.keyboard.international2"), + (137, "key.keyboard.international3"), + (138, "key.keyboard.international4"), + (139, "key.keyboard.international5"), + (140, "key.keyboard.international6"), + (141, "key.keyboard.international7"), + (142, "key.keyboard.international8"), + (143, "key.keyboard.international9"), + (144, "key.keyboard.lang1"), + (145, "key.keyboard.lang2"), + (146, "key.keyboard.lang3"), + (147, "key.keyboard.lang4"), + (148, "key.keyboard.lang5"), + (149, "key.keyboard.lang6"), + (150, "key.keyboard.lang7"), + (151, "key.keyboard.lang8"), + (152, "key.keyboard.lang9"), + (153, "key.keyboard.alternate.erase"), + (154, "key.keyboard.sys.req"), + (155, "key.keyboard.cancel"), + (156, "key.keyboard.clear"), + (157, "key.keyboard.prior"), + (158, "key.keyboard.enter2"), + (159, "key.keyboard.separator"), + (160, "key.keyboard.out"), + (161, "key.keyboard.oper"), + (162, "key.keyboard.clear.again"), + (163, "key.keyboard.crsel"), + (164, "key.keyboard.exsel"), + (176, "key.keyboard.keypad.00"), + (177, "key.keyboard.keypad.000"), + (178, "key.keyboard.thousands.separator"), + (179, "key.keyboard.decimal.separator"), + (180, "key.keyboard.currency.unit"), + (181, "key.keyboard.currency.subunit"), + (182, "key.keyboard.keypad.left.parenthesis"), + (183, "key.keyboard.keypad.right.parenthesis"), + (184, "key.keyboard.keypad.left.brace"), + (185, "key.keyboard.keypad.right.brace"), + (186, "key.keyboard.keypad.tab"), + (187, "key.keyboard.keypad.backspace"), + (188, "key.keyboard.keypad.a"), + (189, "key.keyboard.keypad.b"), + (190, "key.keyboard.keypad.c"), + (191, "key.keyboard.keypad.d"), + (192, "key.keyboard.keypad.e"), + (193, "key.keyboard.keypad.f"), + (194, "key.keyboard.keypad.xor"), + (195, "key.keyboard.keypad.power"), + (196, "key.keyboard.keypad.percent"), + (197, "key.keyboard.keypad.less"), + (198, "key.keyboard.keypad.greater"), + (199, "key.keyboard.keypad.ampersand"), + (200, "key.keyboard.keypad.double.ampersand"), + (201, "key.keyboard.keypad.vertical.bar"), + (202, "key.keyboard.keypad.double.vertical.bar"), + (203, "key.keyboard.keypad.colon"), + (204, "key.keyboard.keypad.hash"), + (205, "key.keyboard.keypad.space"), + (206, "key.keyboard.keypad.at"), + (207, "key.keyboard.keypad.exclamation"), + (208, "key.keyboard.keypad.memory.store"), + (209, "key.keyboard.keypad.memory.recall"), + (210, "key.keyboard.keypad.memory.clear"), + (211, "key.keyboard.keypad.memory.add"), + (212, "key.keyboard.keypad.memory.subtract"), + (213, "key.keyboard.keypad.memory.multiply"), + (214, "key.keyboard.keypad.memory.divide"), + (215, "key.keyboard.keypad.plus.minus"), + (216, "key.keyboard.keypad.clear"), + (217, "key.keyboard.keypad.clear.entry"), + (218, "key.keyboard.keypad.binary"), + (219, "key.keyboard.keypad.octal"), + (220, "key.keyboard.keypad.decimal"), + (221, "key.keyboard.keypad.hexadecimal"), + (224, "key.keyboard.left.control"), + (225, "key.keyboard.left.shift"), + (226, "key.keyboard.left.alt"), + (227, "key.keyboard.left.win"), + (228, "key.keyboard.right.control"), + (229, "key.keyboard.right.shift"), + (230, "key.keyboard.right.alt"), + (231, "key.keyboard.right.win"), + (257, "key.keyboard.mode"), + (258, "key.keyboard.sleep"), + (259, "key.keyboard.wake"), + (260, "key.keyboard.channel.up"), + (261, "key.keyboard.channel.down"), + (262, "key.keyboard.media.play"), + (263, "key.keyboard.media.pause"), + (264, "key.keyboard.media.record"), + (265, "key.keyboard.media.fast.forward"), + (266, "key.keyboard.media.rewind"), + (267, "key.keyboard.media.next.track"), + (268, "key.keyboard.media.previous.track"), + (269, "key.keyboard.media.stop"), + (270, "key.keyboard.media.eject"), + (271, "key.keyboard.media.play.pause"), + (272, "key.keyboard.media.select"), + (273, "key.keyboard.ac.new"), + (274, "key.keyboard.ac.open"), + (275, "key.keyboard.ac.close"), + (276, "key.keyboard.ac.exit"), + (277, "key.keyboard.ac.save"), + (278, "key.keyboard.ac.print"), + (279, "key.keyboard.ac.properties"), + (280, "key.keyboard.ac.search"), + (281, "key.keyboard.ac.home"), + (282, "key.keyboard.ac.back"), + (283, "key.keyboard.ac.forward"), + (284, "key.keyboard.ac.stop"), + (285, "key.keyboard.ac.refresh"), + (286, "key.keyboard.ac.bookmarks"), + (287, "key.keyboard.soft.left"), + (288, "key.keyboard.soft.right"), + (289, "key.keyboard.call"), + (290, "key.keyboard.end.call"), +]; + +/// Mouse buttons: (button number, key name). +pub const MOUSE: &[(i32, &str)] = &[ + (1, "key.mouse.left"), + (2, "key.mouse.middle"), + (3, "key.mouse.right"), + (4, "key.mouse.4"), + (5, "key.mouse.5"), + (6, "key.mouse.6"), + (7, "key.mouse.7"), + (8, "key.mouse.8"), +]; diff --git a/crates/horizon-client/src/keybinds.rs b/crates/horizon-client/src/keybinds.rs index a62323409..155ffcc24 100644 --- a/crates/horizon-client/src/keybinds.rs +++ b/crates/horizon-client/src/keybinds.rs @@ -43,6 +43,7 @@ pub const MAPPINGS: &[(&str, &str, &str)] = &[ ("key.advancements", "key.keyboard.l", "misc"), ("key.quickActions", "key.keyboard.g", "misc"), ("key.debug.overlay", "key.keyboard.f3", "debug"), + ("key.debug.modifier", "key.keyboard.f3", "debug"), ("key.hotbar.1", "key.keyboard.1", "inventory"), ("key.hotbar.2", "key.keyboard.2", "inventory"), ("key.hotbar.3", "key.keyboard.3", "inventory"), @@ -52,7 +53,32 @@ pub const MAPPINGS: &[(&str, &str, &str)] = &[ ("key.hotbar.7", "key.keyboard.7", "inventory"), ("key.hotbar.8", "key.keyboard.8", "inventory"), ("key.hotbar.9", "key.keyboard.9", "inventory"), + ("key.debug.reloadChunk", "key.keyboard.a", "debug"), + ("key.debug.showHitboxes", "key.keyboard.b", "debug"), + ("key.debug.clearChat", "key.keyboard.d", "debug"), + ("key.debug.crash", "key.keyboard.c", "debug"), + ("key.debug.showChunkBorders", "key.keyboard.g", "debug"), + ("key.debug.showAdvancedTooltips", "key.keyboard.h", "debug"), + ("key.debug.copyRecreateCommand", "key.keyboard.i", "debug"), + ("key.debug.spectate", "key.keyboard.n", "debug"), + ("key.debug.switchGameMode", "key.keyboard.f4", "debug"), + ("key.debug.debugOptions", "key.keyboard.f6", "debug"), + ("key.debug.focusPause", "key.keyboard.p", "debug"), + ("key.debug.dumpDynamicTextures", "key.keyboard.s", "debug"), + ("key.debug.reloadResourcePacks", "key.keyboard.t", "debug"), + ("key.debug.profiling", "key.keyboard.l", "debug"), + ("key.debug.copyLocation", "key.keyboard.c", "debug"), + ("key.debug.dumpVersion", "key.keyboard.v", "debug"), + ("key.debug.profilingChart", "key.keyboard.1", "debug"), + ("key.debug.fpsCharts", "key.keyboard.2", "debug"), + ("key.debug.networkCharts", "key.keyboard.3", "debug"), + ("key.debug.lightmapTexture", "key.keyboard.4", "debug"), + ("key.debug.improvedTransparency", "key.keyboard.x", "debug"), ]; +/// Mappings Options builds as `ToggleKeyMapping` (hold or toggle by option). +pub fn is_toggle(name: &str) -> bool { + matches!(name, "key.sneak" | "key.sprint" | "key.use" | "key.attack") +} /// KeyMapping.Category sort order. pub const CATEGORIES: [&str; 8] = [ "movement", diff --git a/crates/horizon-client/src/keymapping.rs b/crates/horizon-client/src/keymapping.rs new file mode 100644 index 000000000..157e59cb8 --- /dev/null +++ b/crates/horizon-client/src/keymapping.rs @@ -0,0 +1,110 @@ +//! The down/click state of `KeyMapping` and `ToggleKeyMapping` (sneak, +//! sprint, attack and use can be toggled instead of held). + +/// One mapping's runtime state. `toggle` is `Some(restore)` for a +/// `ToggleKeyMapping` (with its `shouldRestore` flag), `None` for a plain one. +#[derive(Clone, Debug)] +pub struct KeyState { + pub is_down: bool, + click_count: i32, + released_by_screen_when_down: bool, + toggle: Option, + keyboard: bool, +} + +impl KeyState { + pub fn plain() -> Self { + Self { + is_down: false, + click_count: 0, + released_by_screen_when_down: false, + toggle: None, + keyboard: true, + } + } + /// A `ToggleKeyMapping`; `keyboard` is whether the bound key is a keyboard key. + pub fn toggle(should_restore: bool, keyboard: bool) -> Self { + Self { + toggle: Some(should_restore), + keyboard, + ..Self::plain() + } + } + /// `KeyMapping.click`: one more pending click. + pub fn click(&mut self) { + self.click_count += 1; + } + /// `consumeClick`. + pub fn consume_click(&mut self) -> bool { + if self.click_count == 0 { + false + } else { + self.click_count -= 1; + true + } + } + /// `setDown`; `needs_toggle` is the mapping's option value. + pub fn set_down(&mut self, down: bool, needs_toggle: bool) { + if self.toggle.is_some() && needs_toggle { + if down { + self.is_down = !self.is_down; + } + } else { + self.is_down = down; + } + } + /// `shouldSetOnIngameFocus` for a keyboard-bound, bound key. + pub fn should_set_on_ingame_focus(&self, needs_toggle: bool) -> bool { + self.keyboard && (self.toggle.is_none() || !needs_toggle) + } + /// `release` (a screen opened): drops pending clicks and the held state. + pub fn release(&mut self, needs_toggle: bool) { + if self.toggle.is_some() { + // ToggleKeyMapping.release does not clear pending clicks. + if needs_toggle && self.is_down || self.released_by_screen_when_down { + self.released_by_screen_when_down = true; + } + self.reset(); + } else { + self.click_count = 0; + self.set_down(false, needs_toggle); + } + } + /// `ToggleKeyMapping.reset`. + pub fn reset(&mut self) { + self.is_down = false; + } + /// `shouldRestoreStateOnScreenClosed` (clears the remembered release). + pub fn should_restore_state_on_screen_closed(&mut self, needs_toggle: bool) -> bool { + let Some(restore) = self.toggle else { + return false; + }; + let result = restore && needs_toggle && self.keyboard && self.released_by_screen_when_down; + self.released_by_screen_when_down = false; + result + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn toggle_flips_on_press_and_ignores_release() { + let mut k = KeyState::toggle(true, true); + k.set_down(true, true); + assert!(k.is_down); + k.set_down(false, true); + assert!(k.is_down); + k.set_down(true, true); + assert!(!k.is_down); + } + #[test] + fn screen_release_restores_toggled_state() { + let mut k = KeyState::toggle(true, true); + k.set_down(true, true); + k.release(true); + assert!(!k.is_down); + assert!(k.should_restore_state_on_screen_closed(true)); + assert!(!k.should_restore_state_on_screen_closed(true)); + } +} diff --git a/crates/horizon-client/src/lib.rs b/crates/horizon-client/src/lib.rs index 089f6fb82..69532768b 100644 --- a/crates/horizon-client/src/lib.rs +++ b/crates/horizon-client/src/lib.rs @@ -37,7 +37,10 @@ pub mod hunger; pub mod input; pub mod item_data; pub mod items; +pub mod java_text; +pub mod key_names; pub mod keybinds; +pub mod keymapping; pub mod landing; pub mod lang; pub mod light; @@ -46,9 +49,12 @@ pub mod mesher; pub mod mobs; pub mod models; pub mod motion; +pub mod mouse; pub mod multiplayer; pub mod music; pub mod net; +pub mod options_file; +pub mod options_fixes; pub mod options_ui; pub mod packs; pub mod particles; @@ -70,6 +76,7 @@ pub mod text; pub mod title; pub mod ui; pub mod vanillagen; +pub mod window; pub mod world; pub mod zip; pub type Result = std::result::Result>; diff --git a/crates/horizon-client/src/mouse.rs b/crates/horizon-client/src/mouse.rs new file mode 100644 index 000000000..98efc7ed4 --- /dev/null +++ b/crates/horizon-client/src/mouse.rs @@ -0,0 +1,283 @@ +//! Mouse look and scrolling of 26.3: `MouseHandler` (accumulated movement, +//! sensitivity curve, cinematic smoothing, inversion), `SmoothDouble`, +//! `ScrollWheelHandler` and `Entity.turn`. + +/// `SmoothDouble`. +#[derive(Clone, Debug, Default)] +pub struct SmoothDouble { + target_value: f64, + remaining_value: f64, + last_amount: f64, +} + +impl SmoothDouble { + pub fn get_new_delta_value(&mut self, target_delta: f64, time: f64) -> f64 { + self.target_value += target_delta; + let mut delta = self.target_value - self.remaining_value; + let new_last_amount = self.last_amount + 0.5 * (delta - self.last_amount); + let delta_sign = java_signum(delta); + if delta_sign * delta > delta_sign * self.last_amount { + delta = new_last_amount; + } + self.last_amount = new_last_amount; + self.remaining_value += delta * time; + delta * time + } + pub fn reset(&mut self) { + *self = Self::default(); + } +} + +/// `Math.signum(double)`. +pub fn java_signum(v: f64) -> f64 { + if v == 0.0 || v.is_nan() { v } else { v.signum() } +} + +/// `ScrollWheelHandler`. +#[derive(Clone, Debug, Default)] +pub struct ScrollWheelHandler { + accumulated_x: f64, + accumulated_y: f64, +} + +impl ScrollWheelHandler { + /// `onMouseScroll`: whole wheel steps `(x, y)` once enough has accumulated. + pub fn on_mouse_scroll(&mut self, x: f64, y: f64) -> (i32, i32) { + if self.accumulated_x != 0.0 && java_signum(x) != java_signum(self.accumulated_x) { + self.accumulated_x = 0.0; + } + if self.accumulated_y != 0.0 && java_signum(y) != java_signum(self.accumulated_y) { + self.accumulated_y = 0.0; + } + self.accumulated_x += x; + self.accumulated_y += y; + // Java's double-to-int cast saturates and maps NaN to zero, like Rust's. + let wheel_x = self.accumulated_x as i32; + let wheel_y = self.accumulated_y as i32; + if wheel_x == 0 && wheel_y == 0 { + return (0, 0); + } + self.accumulated_x -= f64::from(wheel_x); + self.accumulated_y -= f64::from(wheel_y); + (wheel_x, wheel_y) + } + + /// `getNextScrollWheelSelection`. + pub fn next_selection(wheel: f64, current_selected: i32, limit: i32) -> i32 { + let step = java_signum(wheel) as i32; + let mut current = (current_selected - step).max(-1); + while current < 0 { + current += limit; + } + while current >= limit { + current -= limit; + } + current + } +} + +/// Entity rotation as `Entity.turn` keeps it. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct Rotation { + pub x_rot: f32, + pub y_rot: f32, + pub x_rot_o: f32, + pub y_rot_o: f32, +} + +impl Rotation { + fn set_x_rot(&mut self, x_rot: f32) { + if x_rot.is_finite() { + self.x_rot = (x_rot % 360.0).clamp(-90.0, 90.0); + } + } + fn set_y_rot(&mut self, y_rot: f32) { + if y_rot.is_finite() { + self.y_rot = y_rot; + } + } + /// `Entity.turn(xo, yo)`: mouse deltas in, 0.15 degrees per unit, pitch clamped. + pub fn turn(&mut self, xo: f64, yo: f64) { + let x_delta = (yo as f32) * 0.15; + let y_delta = (xo as f32) * 0.15; + self.set_x_rot(self.x_rot + x_delta); + self.set_y_rot(self.y_rot + y_delta); + self.set_x_rot(mth_clamp(self.x_rot, -90.0, 90.0)); + self.x_rot_o += x_delta; + self.y_rot_o += y_delta; + self.x_rot_o = mth_clamp(self.x_rot_o, -90.0, 90.0); + } +} + +/// `Mth.clamp(float, float, float)`. +pub fn mth_clamp(value: f32, min: f32, max: f32) -> f32 { + if value < min { + min + } else if value.is_nan() || max.is_nan() { + f32::NAN + } else { + value.min(max) + } +} + +/// The options `turnPlayer` reads. +#[derive(Clone, Copy, Debug)] +pub struct LookOptions { + pub sensitivity: f64, + pub smooth_camera: bool, + /// First-person camera and the player is scoping (spyglass). + pub scoping: bool, + pub invert_x: bool, + pub invert_y: bool, +} + +/// The input state of `MouseHandler` that drives the camera and the hotbar. +#[derive(Clone, Debug)] +pub struct MouseLook { + xpos: f64, + ypos: f64, + ignore_first_move: bool, + smooth_turn_x: SmoothDouble, + smooth_turn_y: SmoothDouble, + accumulated_dx: f64, + accumulated_dy: f64, + pub scroll: ScrollWheelHandler, + last_handle_movement_time: f64, +} + +impl Default for MouseLook { + fn default() -> Self { + Self { + xpos: 0.0, + ypos: 0.0, + ignore_first_move: true, + smooth_turn_x: SmoothDouble::default(), + smooth_turn_y: SmoothDouble::default(), + accumulated_dx: 0.0, + accumulated_dy: 0.0, + scroll: ScrollWheelHandler::default(), + // Double.MIN_VALUE + last_handle_movement_time: 4.9e-324, + } + } +} + +impl MouseLook { + /// `setIgnoreFirstMove`. + pub fn set_ignore_first_move(&mut self) { + self.ignore_first_move = true; + } + + /// `onMove`: relative motion counts while the pointer is grabbed, absolute + /// motion otherwise. + pub fn on_move(&mut self, xpos: f64, ypos: f64, xrel: f64, yrel: f64, window_active: bool, grabbed: bool) { + if self.ignore_first_move { + self.xpos = xpos; + self.ypos = ypos; + self.ignore_first_move = false; + } else { + if window_active { + if grabbed { + self.accumulated_dx += xrel; + self.accumulated_dy += yrel; + } else { + self.accumulated_dx += xpos - self.xpos; + self.accumulated_dy += ypos - self.ypos; + } + } + self.xpos = xpos; + self.ypos = ypos; + } + } + + /// Movement accumulated since the last frame (for screens' mouse-moved events). + pub fn accumulated(&self) -> (f64, f64) { + (self.accumulated_dx, self.accumulated_dy) + } + + /// `handleAccumulatedMovement` for a frame at `time` seconds: the + /// `(xo, yo)` passed to `Entity.turn` when the pointer is grabbed and the + /// window is active. The accumulators are cleared either way. + pub fn handle_accumulated_movement( + &mut self, + time: f64, + window_active: bool, + grabbed_with_player: bool, + look: LookOptions, + ) -> Option<(f64, f64)> { + let mousea = time - self.last_handle_movement_time; + self.last_handle_movement_time = time; + let turn = (window_active && grabbed_with_player).then(|| self.turn_player(mousea, look)); + self.accumulated_dx = 0.0; + self.accumulated_dy = 0.0; + turn + } + + fn turn_player(&mut self, mousea: f64, look: LookOptions) -> (f64, f64) { + let ss = look.sensitivity * f64::from(0.6f32) + f64::from(0.2f32); + let sensitivity_mod = ss * ss * ss; + let sens = sensitivity_mod * 8.0; + let (xo, yo) = if look.smooth_camera { + ( + self.smooth_turn_x.get_new_delta_value(self.accumulated_dx * sens, mousea * sens), + self.smooth_turn_y.get_new_delta_value(self.accumulated_dy * sens, mousea * sens), + ) + } else if look.scoping { + self.smooth_turn_x.reset(); + self.smooth_turn_y.reset(); + (self.accumulated_dx * sensitivity_mod, self.accumulated_dy * sensitivity_mod) + } else { + self.smooth_turn_x.reset(); + self.smooth_turn_y.reset(); + (self.accumulated_dx * sens, self.accumulated_dy * sens) + }; + (if look.invert_x { -xo } else { xo }, if look.invert_y { -yo } else { yo }) + } + + /// `onScroll` for the in-game case (no screen, player present): the wheel + /// value `wheel` the hotbar or spectator speed reacts to, and the raw + /// wheel steps. `None` when no whole step has accumulated. + pub fn on_scroll( + &mut self, + xoffset: f64, + yoffset: f64, + discrete: bool, + wheel_sensitivity: f64, + ) -> Option<(i32, (i32, i32))> { + let scale = |v: f64| (if discrete { java_signum(v) } else { v }) * wheel_sensitivity; + let (x, y) = self.scroll.on_mouse_scroll(scale(xoffset), scale(yoffset)); + if x == 0 && y == 0 { + return None; + } + let wheel = if y == 0 { -x } else { y }; + Some((wheel, (x, y))) + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn default_sensitivity_turns_point_fifteen_degrees_per_count_at_one() { + let mut look = MouseLook::default(); + look.on_move(0.0, 0.0, 0.0, 0.0, true, true); + look.on_move(1.0, 0.0, 1.0, 0.0, true, true); + let (xo, _) = look + .handle_accumulated_movement( + 1.0, + true, + true, + LookOptions { sensitivity: 0.5, smooth_camera: false, scoping: false, invert_x: false, invert_y: false }, + ) + .unwrap(); + let mut rot = Rotation { x_rot: 0.0, y_rot: 0.0, x_rot_o: 0.0, y_rot_o: 0.0 }; + rot.turn(xo, 0.0); + assert!((rot.y_rot - 0.15 * 1.0).abs() < 1e-6, "{}", rot.y_rot); + } + #[test] + fn scroll_accumulates_fractions() { + let mut look = MouseLook::default(); + assert_eq!(look.on_scroll(0.0, 0.4, false, 1.0), None); + assert_eq!(look.on_scroll(0.0, 0.7, false, 1.0), Some((1, (0, 1)))); + } +} diff --git a/crates/horizon-client/src/options_file.rs b/crates/horizon-client/src/options_file.rs new file mode 100644 index 000000000..50bfa80ab --- /dev/null +++ b/crates/horizon-client/src/options_file.rs @@ -0,0 +1,717 @@ +//! `options.txt` exactly as `Options.load`/`Options.save` handle it in 26.3: +//! the processing order, per-option codecs and validation (`OptionInstance`), +//! plain fields, key mappings, sound volumes and model parts. Typed access for +//! the game lives in `settings`. +use crate::{ + java_text::{self, Json}, + key_names, +}; +use std::sync::LazyLock; + +/// A stored option value. +#[derive(Clone, Debug, PartialEq)] +pub enum V { + Bool(bool), + Int(i32), + Double(f64), + Str(String), + List(Vec), +} + +/// How an `OptionInstance` decodes, validates and encodes its value. +#[derive(Clone, Copy, Debug)] +pub enum Spec { + /// `Codec.BOOL`. + Bool, + /// `IntRange(min, max)`: codec `intRange(min, max + 1)`, validated to `max`. + Int(i32, i32), + /// `ClampingLazyMaxIntRange(min, ..)` while the game is not running. + LazyInt(i32), + /// `IntRange(imin, imax).xmap(i / k, (int)(v * k))` with `doubleRange(lo, hi)`. + Scaled(i32, i32, f64, f64, f64), + /// The frame rate limit: `IntRange(1, 26).xmap(i * 10, v / 10)`, codec 10..=260. + FrameLimit, + /// Field of view degrees stored as `(fov - 70) / 40`. + Fov, + /// `IntRange(-200, 100).xmap(10^(i/100), floor(log10(v) * 100))`. + WheelSensitivity, + /// `UnitDouble`. + Unit, + /// `UnitDouble.xmap(square, sqrt)` with an explicit `doubleRange(0, 1)` codec. + UnitSquare, + /// `UnitDouble.xmap(square, sqrt)` using the value set's own codec. + UnitSquareImplicit, + /// String-represented enum. + Named(&'static [&'static str]), + /// Enum stored as its id, wrapping out-of-range ids. + Id(i32), + /// `CloudStatus` with the boolean alternative. + Clouds, + /// Any string (`LazyEnum` while the game is not running). + AnyStr, +} + +#[derive(Clone, Copy, Debug)] +enum Kind { + Option(Spec), + PlainBool, + PlainInt, + PlainStr, + List, + Tutorial, + Key, +} + +struct Def { + key: String, + kind: Kind, + default: V, +} + +const TUTORIAL_STEPS: [&str; 6] = [ + "movement", + "find_tree", + "punch_tree", + "open_inventory", + "craft_planks", + "none", +]; +const MODEL_PARTS: [&str; 7] = [ + "cape", + "jacket", + "left_sleeve", + "right_sleeve", + "left_pants_leg", + "right_pants_leg", + "hat", +]; +const GRAPHICS_BACKEND: &[&str] = &["default", "opengl", "vulkan"]; +const GRAPHICS_PRESET: &[&str] = &["fast", "fancy", "fabulous", "custom"]; +const INACTIVITY: &[&str] = &["minimized", "afk"]; +const CLOUDS: &[&str] = &["false", "fast", "true"]; +const MAIN_HAND: &[&str] = &["left", "right"]; +const PRESENCE: &[&str] = &["none", "limited", "all"]; +const MUSIC_TOAST: &[&str] = &["never", "pause", "pause_and_toast"]; +const MUSIC_FREQUENCY: &[&str] = &["DEFAULT", "FREQUENT", "CONSTANT"]; + +fn def(key: &str, kind: Kind, default: V) -> Def { + Def { + key: key.to_owned(), + kind, + default, + } +} + +/// The processing order of `Options.processOptions`. +static TABLE: LazyLock> = LazyLock::new(|| { + use Kind::{List, Option as O, PlainBool as PB, PlainInt as PI, PlainStr as PS, Tutorial}; + use Spec::{ + AnyStr, Bool, Clouds, Fov, FrameLimit, Id, Int, LazyInt, Named, Scaled, Unit, UnitSquare, + UnitSquareImplicit, WheelSensitivity, + }; + let b = |key: &str, d: bool| def(key, O(Bool), V::Bool(d)); + let i = |key: &str, lo, hi, d: i32| def(key, O(Int(lo, hi)), V::Int(d)); + let u = |key: &str, d: f64| def(key, O(Unit), V::Double(d)); + let n = + |key: &str, names: &'static [&'static str], d: i32| def(key, O(Named(names)), V::Int(d)); + let id = |key: &str, count: i32, d: i32| def(key, O(Id(count)), V::Int(d)); + let pb = |key: &str, d: bool| def(key, PB, V::Bool(d)); + let mut t = vec![ + b("ao", true), + i("biomeBlendRadius", 0, 7, 2), + def( + "chunkSectionFadeInTime", + O(Scaled(0, 40, 20.0, 0.0, 2.0)), + V::Double(0.75), + ), + b("cutoutLeaves", true), + b("enableVsync", true), + def( + "entityDistanceScaling", + O(Scaled(2, 20, 4.0, 0.5, 5.0)), + V::Double(1.0), + ), + b("entityShadows", true), + b("forceUnicodeFont", false), + b("japaneseGlyphVariants", false), + def("fov", O(Fov), V::Int(70)), + def("fovEffectScale", O(UnitSquare), V::Double(1.0)), + def("darknessEffectScale", O(UnitSquareImplicit), V::Double(1.0)), + u("glintSpeed", 0.5), + u("glintStrength", 0.75), + n("preferredGraphicsBackend", GRAPHICS_BACKEND, 0), + n("graphicsPreset", GRAPHICS_PRESET, 1), + id("prioritizeChunkUpdates", 3, 0), + b("fullscreen", false), + b("exclusiveFullscreen", false), + b("macFullscreenMenuVisibility", false), + u("gamma", 0.5), + def("guiScale", O(LazyInt(0)), V::Int(0)), + def("debugGuiScale", O(LazyInt(-1)), V::Int(0)), + i("maxAnisotropyBit", 1, 3, 2), + id("textureFiltering", 3, 0), + def("maxFps", O(FrameLimit), V::Int(120)), + b("improvedTransparency", false), + n("inactivityFpsLimit", INACTIVITY, 1), + i("mipmapLevels", 0, 4, 4), + id("narrator", 4, 0), + id("particles", 3, 0), + b("reducedDebugInfo", false), + def("renderClouds", O(Clouds), V::Int(2)), + i("cloudRange", 2, 128, 128), + i("renderDistance", 2, 32, 12), + i("simulationDistance", 5, 32, 12), + u("screenEffectScale", 1.0), + def("soundDevice", O(AnyStr), V::Str(String::new())), + b("vignette", true), + i("weatherRadius", 3, 10, 10), + b("autoJump", false), + b("rotateWithMinecart", false), + b("operatorItemsTab", false), + b("autoSuggestions", true), + b("chatColors", true), + b("chatLinks", true), + b("chatLinksPrompt", true), + b("discrete_mouse_scroll", false), + b("invertXMouse", false), + b("invertYMouse", false), + b("realmsNotifications", true), + b("showSubtitles", false), + b("directionalAudio", false), + b("bobView", true), + b("toggleCrouch", false), + b("toggleSprint", false), + b("toggleAttack", false), + b("toggleUse", false), + i("sprintWindow", 0, 10, 7), + b("darkMojangStudiosBackground", false), + b("hideLightningFlashes", false), + b("hideSplashTexts", false), + u("mouseSensitivity", 0.5), + u("damageTiltStrength", 1.0), + b("highContrast", false), + b("highContrastBlockOutline", false), + b("narratorHotkey", true), + def("resourcePacks", List, V::List(Vec::new())), + def("incompatibleResourcePacks", List, V::List(Vec::new())), + def("lastServer", PS, V::Str(String::new())), + def("lang", PS, V::Str("en_us".into())), + id("chatVisibility", 3, 0), + u("chatOpacity", 1.0), + u("chatLineSpacing", 0.0), + u("textBackgroundOpacity", 0.5), + b("backgroundForChatOnly", true), + pb("hideServerAddress", false), + pb("advancedItemTooltips", false), + pb("pauseOnLostFocus", true), + def("overrideWidth", PI, V::Int(0)), + def("overrideHeight", PI, V::Int(0)), + u("chatHeightFocused", 1.0), + def( + "chatDelay", + O(Scaled(0, 60, 10.0, 0.0, 6.0)), + V::Double(0.0), + ), + u("chatHeightUnfocused", 0.4375), + u("chatScale", 1.0), + u("chatWidth", 1.0), + def( + "notificationDisplayTime", + O(Scaled(5, 100, 10.0, 0.5, 10.0)), + V::Double(1.0), + ), + pb("useNativeTransport", true), + n("mainHand", MAIN_HAND, 1), + id("attackIndicator", 3, 1), + def("tutorialStep", Tutorial, V::Int(0)), + def("mouseWheelSensitivity", O(WheelSensitivity), V::Double(1.0)), + b("allowCursorChanges", true), + b("quitShortcuts", true), + b("ctrlClickEmulatesRightClick", false), + def("glDebugVerbosity", PI, V::Int(1)), + pb("skipMultiplayerWarning", false), + b("hideMatchedNames", true), + pb("joinedFirstServer", false), + pb("syncChunkWrites", false), + b("showAutosaveIndicator", true), + b("allowServerListing", true), + b("inGameNotification", false), + n("sharePresence", PRESENCE, 2), + b("onlyShowSecureChat", false), + b("saveChatDrafts", false), + u("panoramaScrollSpeed", 1.0), + b("telemetryOptInExtra", false), + pb("onboardAccessibility", true), + i("menuBackgroundBlurriness", 0, 10, 5), + pb("startedCleanly", true), + n("musicToast", MUSIC_TOAST, 0), + n("musicFrequency", MUSIC_FREQUENCY, 0), + ]; + for (name, key, _) in crate::keybinds::MAPPINGS { + t.push(def( + &format!("key_{name}"), + Kind::Key, + V::Str((*key).to_owned()), + )); + } + for source in crate::settings::SOUND_SOURCES { + t.push(u(&format!("soundCategory_{source}"), 1.0)); + } + for part in MODEL_PARTS { + t.push(pb(&format!("modelPart_{part}"), true)); + } + t +}); + +/// Mth.floor for doubles. +fn floor_int(v: f64) -> i32 { + let i = v as i32; + if v < f64::from(i) { i - 1 } else { i } +} + +fn number(json: &Json) -> Option<&str> { + match json { + Json::Number(n) => Some(n), + _ => None, + } +} +fn codec_int(json: &Json) -> Option { + number(json).map(Json::int_value) +} +fn codec_double(json: &Json) -> Option { + number(json).map(Json::double_value) +} +fn codec_bool(json: &Json) -> Option { + match json { + Json::Bool(b) => Some(*b), + _ => None, + } +} +fn codec_string(json: &Json) -> Option<&str> { + match json { + Json::String(s) => Some(s), + _ => None, + } +} +fn double_range(v: f64, lo: f64, hi: f64) -> Option { + // Double.compareTo: -0.0 sorts below 0.0 and NaN above everything. + (v.total_cmp(&lo).is_ge() && v.total_cmp(&hi).is_le() && !v.is_nan()).then_some(v) +} +fn log_mouse(value: i32) -> f64 { + 10f64.powf(f64::from(value) / 100.0) +} +fn unit_alt(json: &Json) -> Option { + codec_double(json) + .and_then(|v| double_range(v, 0.0, 1.0)) + .or_else(|| codec_bool(json).map(|b| if b { 1.0 } else { 0.0 })) +} + +impl Spec { + /// `codec.parse(JsonOps.INSTANCE, element)`. + fn decode(self, json: &Json) -> Option { + match self { + Spec::Bool => codec_bool(json).map(V::Bool), + Spec::Int(lo, hi) => { + let v = codec_int(json)?; + (v >= lo && i64::from(v) <= i64::from(hi) + 1).then_some(V::Int(v)) + } + Spec::LazyInt(lo) => { + let v = codec_int(json)?; + (v >= lo).then_some(V::Int(v)) + } + Spec::Scaled(.., lo, hi) => double_range(codec_double(json)?, lo, hi).map(V::Double), + Spec::FrameLimit => { + let v = codec_int(json)?; + (10..=260).contains(&v).then_some(V::Int(v)) + } + Spec::Fov => Some(V::Int((codec_double(json)? * 40.0 + 70.0) as i32)), + Spec::WheelSensitivity => { + double_range(codec_double(json)?, log_mouse(-200), log_mouse(100)).map(V::Double) + } + Spec::Unit => unit_alt(json).map(V::Double), + Spec::UnitSquare => double_range(codec_double(json)?, 0.0, 1.0).map(V::Double), + Spec::UnitSquareImplicit => unit_alt(json).map(|v| V::Double(v * v)), + Spec::Named(names) => { + let s = codec_string(json)?; + names.iter().position(|n| *n == s).map(|i| V::Int(i as i32)) + } + Spec::Id(count) => codec_int(json).map(|v| V::Int(v.rem_euclid(count))), + Spec::Clouds => { + if let Some(s) = codec_string(json) { + return CLOUDS + .iter() + .position(|n| *n == s) + .map(|i| V::Int(i as i32)); + } + codec_bool(json).map(|b| V::Int(if b { 2 } else { 0 })) + } + Spec::AnyStr => codec_string(json).map(|s| V::Str(s.to_owned())), + } + } + + /// `ValueSet.validateValue`; `None` makes `OptionInstance.set` fall back + /// to the option's initial value. + fn validate(self, v: &V) -> Option { + match (self, v) { + (Spec::Bool, V::Bool(_)) => Some(v.clone()), + (Spec::Int(lo, hi), V::Int(x)) => (*x >= lo && *x <= hi).then(|| v.clone()), + (Spec::LazyInt(lo), V::Int(x)) => Some(V::Int((*x).clamp(lo, 2_147_483_646))), + (Spec::Scaled(imin, imax, k, ..), V::Double(x)) => { + let i = (x * k) as i32; + (i >= imin && i <= imax).then(|| V::Double(f64::from(i) / k)) + } + (Spec::FrameLimit, V::Int(x)) => { + let i = x / 10; + (1..=26).contains(&i).then(|| V::Int(i * 10)) + } + (Spec::Fov, V::Int(x)) => (30..=110).contains(x).then(|| v.clone()), + (Spec::WheelSensitivity, V::Double(x)) => { + let i = floor_int(x.log10() * 100.0); + (-200..=100).contains(&i).then(|| V::Double(log_mouse(i))) + } + (Spec::Unit, V::Double(x)) => (*x >= 0.0 && *x <= 1.0).then(|| v.clone()), + (Spec::UnitSquare | Spec::UnitSquareImplicit, V::Double(x)) => { + let root = x.sqrt(); + (0.0..=1.0).contains(&root).then_some(V::Double(root * root)) + } + (Spec::Named(names), V::Int(x)) => { + (*x >= 0 && (*x as usize) < names.len()).then(|| v.clone()) + } + (Spec::Id(count), V::Int(x)) => (*x >= 0 && *x < count).then(|| v.clone()), + (Spec::Clouds, V::Int(x)) => (0..3).contains(x).then(|| v.clone()), + (Spec::AnyStr, V::Str(_)) => Some(v.clone()), + _ => None, + } + } + + /// `codec.encodeStart(JsonOps.INSTANCE, value)` rendered by Gson. + fn encode(self, v: &V) -> Option { + let double = |x: f64| java_text::double_to_string(x); + Some(match (self, v) { + (Spec::Bool, V::Bool(b)) => b.to_string(), + (Spec::Int(lo, hi), V::Int(x)) => { + if *x < lo || i64::from(*x) > i64::from(hi) + 1 { + return None; + } + x.to_string() + } + (Spec::LazyInt(lo), V::Int(x)) => { + if *x < lo { + return None; + } + x.to_string() + } + (Spec::Scaled(.., lo, hi), V::Double(x)) => { + double_range(*x, lo, hi)?; + double(*x) + } + (Spec::FrameLimit, V::Int(x)) => { + if !(10..=260).contains(x) { + return None; + } + x.to_string() + } + (Spec::Fov, V::Int(x)) => double((f64::from(*x) - 70.0) / 40.0), + (Spec::WheelSensitivity, V::Double(x)) => { + double_range(*x, log_mouse(-200), log_mouse(100))?; + double(*x) + } + (Spec::Unit, V::Double(x)) => { + double_range(*x, 0.0, 1.0)?; + double(*x) + } + (Spec::UnitSquare, V::Double(x)) => { + double_range(*x, 0.0, 1.0)?; + double(*x) + } + (Spec::UnitSquareImplicit, V::Double(x)) => { + let root = x.sqrt(); + double_range(root, 0.0, 1.0)?; + double(root) + } + (Spec::Named(names), V::Int(x)) => { + java_text::gson_string(names.get(usize::try_from(*x).ok()?)?) + } + (Spec::Id(_), V::Int(x)) => x.to_string(), + (Spec::Clouds, V::Int(x)) => { + java_text::gson_string(CLOUDS.get(usize::try_from(*x).ok()?)?) + } + (Spec::AnyStr, V::Str(s)) => java_text::gson_string(s), + _ => return None, + }) + } +} + +/// `InputConstants.getKey(name)`: the canonical name of a key, or the +/// unbound key when `name` is invalid. +pub fn canonical_key(name: &str) -> Result { + for (_, n) in key_names::KEYBOARD.iter().chain(key_names::MOUSE) { + if *n == name { + return Ok(name.to_owned()); + } + } + for (prefix, table) in [ + ("key.keyboard", key_names::KEYBOARD), + ("key.mouse", key_names::MOUSE), + ] { + if let Some(rest) = name.strip_prefix(prefix) { + // substring(prefix.length() + 1): the separator is skipped blindly. + let mut chars = rest.chars(); + if chars.next().is_none() { + // StringIndexOutOfBoundsException is not an IllegalArgumentException. + return Err(java_text::SyntaxError); + } + let Some(value) = crate::options_fixes::java_parse_int(chars.as_str()) else { + return Ok("key.keyboard.unknown".into()); + }; + return Ok(table + .iter() + .find(|(v, _)| *v == value) + .map_or_else(|| format!("{prefix}.{value}"), |(_, n)| (*n).to_owned())); + } + } + Ok("key.keyboard.unknown".into()) +} + +fn read_list(text: &str) -> Result, java_text::SyntaxError> { + // GsonHelper.fromNullableJson with a List type token. + Ok(java_text::parse_strict_string_list(text)?.unwrap_or_default()) +} + +/// All option values in `processOptions` order. +#[derive(Clone, Debug, PartialEq)] +pub struct OptionsFile { + values: Vec, + /// `fullscreenResolution`, kept verbatim. + pub fullscreen_resolution: Option, +} + +impl Default for OptionsFile { + fn default() -> Self { + Self { + values: TABLE.iter().map(|d| d.default.clone()).collect(), + fullscreen_resolution: None, + } + } +} + +impl OptionsFile { + fn index(key: &str) -> Option { + TABLE.iter().position(|d| d.key == key) + } + pub fn get(&self, key: &str) -> Option<&V> { + Self::index(key).map(|i| &self.values[i]) + } + pub fn bool(&self, key: &str) -> bool { + matches!(self.get(key), Some(V::Bool(true))) + } + pub fn int(&self, key: &str) -> i32 { + match self.get(key) { + Some(V::Int(i)) => *i, + _ => 0, + } + } + pub fn double(&self, key: &str) -> f64 { + match self.get(key) { + Some(V::Double(d)) => *d, + _ => 0.0, + } + } + pub fn string(&self, key: &str) -> String { + match self.get(key) { + Some(V::Str(s)) => s.clone(), + _ => String::new(), + } + } + pub fn list(&self, key: &str) -> Vec { + match self.get(key) { + Some(V::List(l)) => l.clone(), + _ => Vec::new(), + } + } + /// The serialized name of an enum-valued option. + pub fn name(&self, key: &str) -> String { + let Some(i) = Self::index(key) else { + return String::new(); + }; + match (TABLE[i].kind, &self.values[i]) { + (Kind::Option(Spec::Named(names)), V::Int(x)) => { + names.get(*x as usize).copied().unwrap_or("").to_owned() + } + (Kind::Option(Spec::Clouds), V::Int(x)) => { + CLOUDS.get(*x as usize).copied().unwrap_or("").to_owned() + } + _ => String::new(), + } + } + /// `OptionInstance.set` with a candidate value (invalid values revert to + /// the initial value). + pub fn set(&mut self, key: &str, value: V) { + let Some(i) = Self::index(key) else { return }; + let Kind::Option(spec) = TABLE[i].kind else { + self.values[i] = value; + return; + }; + self.values[i] = spec + .validate(&value) + .unwrap_or_else(|| TABLE[i].default.clone()); + } + /// Select an enum option by serialized name. + pub fn set_name(&mut self, key: &str, name: &str) { + let Some(i) = Self::index(key) else { return }; + let names: &[&str] = match TABLE[i].kind { + Kind::Option(Spec::Named(names)) => names, + Kind::Option(Spec::Clouds) => CLOUDS, + _ => return, + }; + if let Some(p) = names.iter().position(|n| *n == name) { + self.values[i] = V::Int(p as i32); + } + } + /// Key mapping value by mapping name. + pub fn key_binding(&self, name: &str) -> String { + self.string(&format!("key_{name}")) + } + + /// `Options.load` on the text of an options file. + pub fn parse(text: &str) -> Self { + let mut file = Self::default(); + let mut raw: std::collections::HashMap = std::collections::HashMap::new(); + for line in split_lines(text) { + if let Some((k, v)) = line.split_once(':') { + raw.insert(k.to_owned(), v.to_owned()); + } + } + let version = raw + .get("version") + .and_then(|v| crate::options_fixes::java_parse_int(v)) + .unwrap_or(0); + // A fixer failure abandons the whole file, leaving the defaults. + if crate::options_fixes::update(&mut raw, version).is_ok() { + file.apply(&raw); + } + file + } + + fn apply(&mut self, raw: &std::collections::HashMap) { + // A syntax error aborts the rest of the load, fullscreenResolution included. + if self.try_apply(raw).is_ok() + && let Some(r) = raw.get("fullscreenResolution") + { + self.fullscreen_resolution = Some(r.clone()); + } + } + + fn try_apply( + &mut self, + raw: &std::collections::HashMap, + ) -> Result<(), java_text::SyntaxError> { + for (i, d) in TABLE.iter().enumerate() { + let Some(text) = raw.get(&d.key) else { + continue; + }; + match d.kind { + Kind::Option(spec) => { + let json = + java_text::parse_lenient(if text.is_empty() { "\"\"" } else { text })?; + if let Some(decoded) = spec.decode(&json) { + self.values[i] = + spec.validate(&decoded).unwrap_or_else(|| d.default.clone()); + } + } + Kind::PlainBool => self.values[i] = V::Bool(text == "true"), + Kind::PlainInt => { + if let Some(v) = crate::options_fixes::java_parse_int(text) { + self.values[i] = V::Int(v); + } + } + Kind::PlainStr => self.values[i] = V::Str(text.clone()), + Kind::List => self.values[i] = V::List(read_list(text)?), + Kind::Tutorial => { + let step = TUTORIAL_STEPS.iter().position(|n| n == text).unwrap_or(5); + self.values[i] = V::Int(step as i32); + } + Kind::Key => { + let V::Str(current) = &self.values[i] else { + continue; + }; + if current != text { + self.values[i] = V::Str(canonical_key(text)?); + } + } + } + } + Ok(()) + } + + /// `Options.save`. + pub fn serialize(&self) -> String { + let mut out = format!("version:{}\n", horizon_world::DATA_VERSION); + for (d, v) in TABLE.iter().zip(&self.values) { + let rendered = match (d.kind, v) { + (Kind::Option(spec), v) => match spec.encode(v) { + Some(s) => s, + None => continue, + }, + (Kind::PlainBool, V::Bool(b)) => b.to_string(), + (Kind::PlainInt, V::Int(x)) => x.to_string(), + (Kind::PlainStr | Kind::Key, V::Str(s)) => s.clone(), + (Kind::List, V::List(items)) => { + let parts: Vec = + items.iter().map(|s| java_text::gson_string(s)).collect(); + format!("[{}]", parts.join(",")) + } + (Kind::Tutorial, V::Int(x)) => TUTORIAL_STEPS + .get(*x as usize) + .copied() + .unwrap_or("none") + .to_owned(), + _ => continue, + }; + out.push_str(&d.key); + out.push(':'); + out.push_str(&rendered); + out.push('\n'); + } + if let Some(r) = &self.fullscreen_resolution { + out.push_str("fullscreenResolution:"); + out.push_str(r); + out.push('\n'); + } + out + } +} + +/// `BufferedReader.lines()`: \n, \r\n and \r terminate lines. +fn split_lines(text: &str) -> Vec<&str> { + let mut lines = Vec::new(); + let bytes = text.as_bytes(); + let mut start = 0; + let mut i = 0; + while i < bytes.len() { + match bytes[i] { + b'\n' => { + lines.push(&text[start..i]); + start = i + 1; + } + b'\r' => { + lines.push(&text[start..i]); + if bytes.get(i + 1) == Some(&b'\n') { + i += 1; + } + start = i + 1; + } + _ => {} + } + i += 1; + } + if start < bytes.len() { + lines.push(&text[start..]); + } + lines +} + +/// Option names in processing order (for tests and tooling). +pub fn keys() -> Vec<&'static str> { + TABLE.iter().map(|d| d.key.as_str()).collect() +} diff --git a/crates/horizon-client/src/options_fixes.rs b/crates/horizon-client/src/options_fixes.rs new file mode 100644 index 000000000..a11248925 --- /dev/null +++ b/crates/horizon-client/src/options_fixes.rs @@ -0,0 +1,319 @@ +//! The `OPTIONS` data fixers of 26.3 (`DataFixTypes.OPTIONS`), applied to the +//! raw key/value strings of an `options.txt` older than the current version. +use std::collections::HashMap; + +/// A fixer threw an exception; vanilla abandons loading the file. +#[derive(Debug)] +pub struct FixFailed; + +pub type Raw = HashMap; + +/// OptionsKeyLwjgl3Fix.MAP: GLFW 2 key codes to key names. +const LWJGL3: &[(i32, &str)] = &[ + (0, "key.unknown"), + (11, "key.0"), + (2, "key.1"), + (3, "key.2"), + (4, "key.3"), + (5, "key.4"), + (6, "key.5"), + (7, "key.6"), + (8, "key.7"), + (9, "key.8"), + (10, "key.9"), + (30, "key.a"), + (40, "key.apostrophe"), + (48, "key.b"), + (43, "key.backslash"), + (14, "key.backspace"), + (46, "key.c"), + (58, "key.caps.lock"), + (51, "key.comma"), + (32, "key.d"), + (211, "key.delete"), + (208, "key.down"), + (18, "key.e"), + (207, "key.end"), + (28, "key.enter"), + (13, "key.equal"), + (1, "key.escape"), + (33, "key.f"), + (59, "key.f1"), + (68, "key.f10"), + (87, "key.f11"), + (88, "key.f12"), + (100, "key.f13"), + (101, "key.f14"), + (102, "key.f15"), + (103, "key.f16"), + (104, "key.f17"), + (105, "key.f18"), + (113, "key.f19"), + (60, "key.f2"), + (61, "key.f3"), + (62, "key.f4"), + (63, "key.f5"), + (64, "key.f6"), + (65, "key.f7"), + (66, "key.f8"), + (67, "key.f9"), + (34, "key.g"), + (41, "key.grave.accent"), + (35, "key.h"), + (199, "key.home"), + (23, "key.i"), + (210, "key.insert"), + (36, "key.j"), + (37, "key.k"), + (82, "key.keypad.0"), + (79, "key.keypad.1"), + (80, "key.keypad.2"), + (81, "key.keypad.3"), + (75, "key.keypad.4"), + (76, "key.keypad.5"), + (77, "key.keypad.6"), + (71, "key.keypad.7"), + (72, "key.keypad.8"), + (73, "key.keypad.9"), + (78, "key.keypad.add"), + (83, "key.keypad.decimal"), + (181, "key.keypad.divide"), + (156, "key.keypad.enter"), + (141, "key.keypad.equal"), + (55, "key.keypad.multiply"), + (74, "key.keypad.subtract"), + (38, "key.l"), + (203, "key.left"), + (56, "key.left.alt"), + (26, "key.left.bracket"), + (29, "key.left.control"), + (42, "key.left.shift"), + (219, "key.left.win"), + (50, "key.m"), + (12, "key.minus"), + (49, "key.n"), + (69, "key.num.lock"), + (24, "key.o"), + (25, "key.p"), + (209, "key.page.down"), + (201, "key.page.up"), + (197, "key.pause"), + (52, "key.period"), + (183, "key.print.screen"), + (16, "key.q"), + (19, "key.r"), + (205, "key.right"), + (184, "key.right.alt"), + (27, "key.right.bracket"), + (157, "key.right.control"), + (54, "key.right.shift"), + (220, "key.right.win"), + (31, "key.s"), + (70, "key.scroll.lock"), + (39, "key.semicolon"), + (53, "key.slash"), + (57, "key.space"), + (20, "key.t"), + (15, "key.tab"), + (22, "key.u"), + (200, "key.up"), + (47, "key.v"), + (17, "key.w"), + (45, "key.x"), + (21, "key.y"), + (44, "key.z"), +]; + +/// `Integer.parseInt(String)`. +pub fn java_parse_int(text: &str) -> Option { + let digits = text.strip_prefix(['+', '-']).unwrap_or(text); + if digits.is_empty() || !digits.chars().all(|c| c.is_ascii_digit()) { + return None; + } + text.parse::().ok() +} + +enum Number<'a> { + Special(f64), + Decimal(bool, &'a str), +} + +fn java_number(text: &str) -> Option> { + let t = text.trim_matches(|c: char| c <= ' '); + let (negative, body) = match t.strip_prefix('-') { + Some(rest) => (true, rest), + None => (false, t.strip_prefix('+').unwrap_or(t)), + }; + match body { + "NaN" => return Some(Number::Special(f64::NAN)), + "Infinity" => { + return Some(Number::Special(if negative { + f64::NEG_INFINITY + } else { + f64::INFINITY + })); + } + _ => {} + } + let body = body.strip_suffix(['f', 'F', 'd', 'D']).unwrap_or(body); + if body.is_empty() + || !body + .chars() + .all(|c| c.is_ascii_digit() || matches!(c, '.' | 'e' | 'E' | '+' | '-')) + || !body.chars().any(|c| c.is_ascii_digit()) + { + return None; + } + Some(Number::Decimal(negative, body)) +} + +/// `Double.parseDouble(String)` for decimal and special forms. +pub fn java_parse_double(text: &str) -> Option { + match java_number(text)? { + Number::Special(v) => Some(v), + Number::Decimal(negative, body) => body + .parse::() + .ok() + .map(|v| if negative { -v } else { v }), + } +} + +/// `Float.parseFloat(String)`. +pub fn java_parse_float(text: &str) -> Option { + match java_number(text)? { + Number::Special(v) => Some(v as f32), + Number::Decimal(negative, body) => body + .parse::() + .ok() + .map(|v| if negative { -v } else { v }), + } +} + +fn rename(raw: &mut Raw, from: &str, to: &str, fix: impl FnOnce(&str) -> String) { + if let Some(old) = raw.remove(from) { + let value = fix(&old); + raw.insert(to.to_owned(), value); + } +} + +/// `OPTIONS` fixers from `version` up to the current data version. +pub fn update(raw: &mut Raw, version: i32) -> Result<(), FixFailed> { + if version < 816 + && let Some(lang) = raw.get_mut("lang") { + *lang = lang.to_lowercase(); + } + if version < 1344 { + let keys: Vec = raw + .keys() + .filter(|k| k.starts_with("key_")) + .cloned() + .collect(); + for key in keys { + let old = java_parse_int(&raw[&key]).ok_or(FixFailed)?; + let name = if old < 0 { + match old + 100 { + 0 => "key.mouse.left".to_owned(), + 1 => "key.mouse.right".to_owned(), + 2 => "key.mouse.middle".to_owned(), + button => format!("key.mouse.{}", button + 1), + } + } else { + LWJGL3 + .iter() + .find(|(v, _)| *v == old) + .map_or("key.unknown", |(_, n)| n) + .to_owned() + }; + raw.insert(key, name); + } + } + if version < 1446 { + let keys: Vec = raw + .keys() + .filter(|k| k.starts_with("key_")) + .cloned() + .collect(); + for key in keys { + let old = raw[&key].clone(); + if !old.starts_with("key.mouse") && !old.starts_with("scancode.") { + // substring(4) on a shorter value throws. + let rest: String = old.chars().skip(4).collect(); + if old.chars().count() < 4 { + return Err(FixFailed); + } + raw.insert(key, format!("key.keyboard.{rest}")); + } + } + } + if version < 1936 + && let Some(opacity) = raw.get("chatOpacity") { + let background = java_parse_double(opacity).map_or(0.5, |v| (0.9 * v + 0.1) / 2.0); + raw.insert( + "textBackgroundOpacity".into(), + crate::java_text::double_to_string(background), + ); + } + if version < 2556 { + rename(raw, "fancyGraphics", "graphicsMode", |v| { + if v == "true" { "1" } else { "0" }.to_owned() + }); + } + if version < 2558 + && let Some(v) = raw.remove("key_key.swapHands") { + raw.insert("key_key.swapOffhand".into(), v); + } + if version < 3201 { + for key in ["resourcePacks", "incompatibleResourcePacks"] { + if let Some(v) = raw.get_mut(key) { + *v = v.replace("\"programer_art\"", "\"programmer_art\""); + } + } + } + if version < 3214 + && let Some(ao) = raw.get_mut("ao") { + match ao.as_str() { + "0" => *ao = "false".into(), + "1" | "2" => *ao = "true".into(), + _ => {} + } + } + if version < 3319 { + raw.insert("onboardAccessibility".into(), "false".into()); + } + if version < 3943 + && let Some(v) = raw.get_mut("menuBackgroundBlurriness") { + let value = java_parse_float(v).map_or(5, |d| ((d * 10.0) + 0.5).floor() as i32); + *v = value.to_string(); + } + if version < 4651 { + let mode = raw.get("graphicsMode").cloned(); + for (name, fast, fancy, fabulous) in [ + ("cutoutLeaves", "false", "true", "true"), + ("weatherRadius", "5", "10", "10"), + ("vignette", "false", "true", "true"), + ("improvedTransparency", "false", "false", "true"), + ] { + let value = match mode.as_deref() { + Some("2") => fabulous, + Some("0") => fast, + _ => fancy, + }; + raw.insert(name.into(), value.into()); + } + raw.insert("graphicsPreset".into(), "custom".into()); + } + if version < 4661 { + rename(raw, "showNowPlayingToast", "musicToast", |v| { + if v == "false" { + "never" + } else { + "pause_and_toast" + } + .to_owned() + }); + } + if version < 4892 { + raw.insert("preferredGraphicsBackend".into(), "default".into()); + } + Ok(()) +} diff --git a/crates/horizon-client/src/settings.rs b/crates/horizon-client/src/settings.rs index 0ea0c7bdc..afd037249 100644 --- a/crates/horizon-client/src/settings.rs +++ b/crates/horizon-client/src/settings.rs @@ -2,7 +2,8 @@ //! encodings (Options.processOptions); lines Horizon does not know are kept. //! The option screens live in `options_ui`. use crate::keybinds::KeyBinds; -use std::{collections::BTreeMap, fs, path::Path}; +use crate::options_file::{OptionsFile, V}; +use std::{fs, path::Path}; /// SoundSource names in vanilla order. pub const SOUND_SOURCES: [&str; 11] = [ @@ -159,8 +160,13 @@ pub struct Settings { /// Enabled resource packs, bottom first (resourcePacks). pub resource_packs: Vec, pub keys: KeyBinds, - /// Lines Horizon does not interpret, kept verbatim. - pub extra: BTreeMap, + /// Every option in its stored form (the typed fields above mirror it). + pub file: OptionsFile, + pub invert_x: bool, + pub toggle_attack: bool, + pub toggle_use: bool, + /// Taps of the sprint key counted as double taps (sprintWindow). + pub sprint_window: i32, } impl Default for Settings { fn default() -> Self { @@ -220,258 +226,220 @@ impl Default for Settings { reduced_debug_info: false, high_contrast: false, main_hand_left: false, - resource_packs: vec!["vanilla".into()], + resource_packs: Vec::new(), keys: KeyBinds::default(), - extra: BTreeMap::new(), + file: OptionsFile::default(), + invert_x: false, + toggle_attack: false, + toggle_use: false, + sprint_window: 7, } } } -fn unquote(v: &str) -> &str { - v.strip_prefix('"') - .and_then(|v| v.strip_suffix('"')) - .unwrap_or(v) +fn put_f(f: &mut OptionsFile, key: &str, v: f32) { + if v != f.double(key) as f32 { + f.set(key, V::Double(f64::from(v))); + } } -fn parse_list(v: &str) -> Vec { - serde_json::from_str::>(v).unwrap_or_default() +fn put_i(f: &mut OptionsFile, key: &str, v: i32) { + if v != f.int(key) { + f.set(key, V::Int(v)); + } +} +fn put_b(f: &mut OptionsFile, key: &str, v: bool) { + if v != f.bool(key) { + f.set(key, V::Bool(v)); + } +} +fn put_name(f: &mut OptionsFile, key: &str, v: &str) { + if v != f.name(key) { + f.set_name(key, v); + } +} +fn put_s(f: &mut OptionsFile, key: &str, v: &str) { + if v != f.string(key) { + f.set(key, V::Str(v.to_owned())); + } } impl Settings { pub fn load(path: &Path) -> Self { - let Ok(text) = fs::read_to_string(path) else { + let Ok(bytes) = fs::read(path) else { return Self::default(); }; - Self::parse(&text) + Self::parse(&String::from_utf8_lossy(&bytes)) } pub fn parse(text: &str) -> Self { - let mut s = Self::default(); - for line in text.lines() { - let Some((k, v)) = line.split_once(':') else { - continue; - }; - let f = |d: f32| v.parse::().unwrap_or(d); - let b = |d: bool| match v { - "true" => true, - "false" => false, - _ => d, - }; - let i = |d: i32| v.parse::().unwrap_or(d); - match k { - "version" => {} - "fov" => { - s.fov = v - .parse::() - .map_or(70.0, |f| (f * 40.0 + 70.0).round().clamp(30.0, 110.0)) - } - "renderDistance" => s.render_distance = i(12).clamp(2, 32), - "simulationDistance" => s.simulation_distance = i(12).clamp(5, 32), - "mouseSensitivity" => s.sensitivity = f(0.5).clamp(0.0, 1.0), - "guiScale" => s.gui_scale = v.parse().unwrap_or(0), - "bobView" => s.view_bobbing = b(true), - "gamma" => s.gamma = f(0.5).clamp(0.0, 1.0), - "maxFps" => s.max_fps = v.parse::().unwrap_or(260).clamp(10, 260), - "enableVsync" => s.vsync = b(true), - "fullscreen" => s.fullscreen = b(false), - "ao" => s.smooth_lighting = b(true), - "renderClouds" => s.clouds = unquote(v).to_owned(), - "cloudRange" => s.cloud_range = i(128).clamp(2, 128), - "particles" => s.particles = v.parse::().unwrap_or(0).min(2), - "entityDistanceScaling" => s.entity_distance = f(1.0).clamp(0.5, 5.0), - "entityShadows" => s.entity_shadows = b(true), - "biomeBlendRadius" => s.biome_blend = i(2).clamp(0, 7), - "graphicsPreset" => s.graphics_preset = unquote(v).to_owned(), - "mipmapLevels" => s.mipmap_levels = i(4).clamp(0, 4), - "weatherRadius" => s.weather_radius = i(10).clamp(3, 10), - "chunkSectionFadeInTime" => s.chunk_fade = f(0.75).clamp(0.0, 2.0), - "vignette" => s.vignette = b(true), - "showAutosaveIndicator" => s.autosave_indicator = b(true), - "cutoutLeaves" => s.cutout_leaves = b(true), - "improvedTransparency" => s.improved_transparency = b(false), - "attackIndicator" => s.attack_indicator = v.parse::().unwrap_or(1).min(2), - "inactivityFpsLimit" => s.inactivity_fps_limit = unquote(v).to_owned(), - "prioritizeChunkUpdates" => { - s.prioritize_chunk_updates = v.parse::().unwrap_or(0).min(2) - } - "menuBackgroundBlurriness" => s.menu_blur = i(5).clamp(0, 10), - "invertYMouse" => s.invert_y = b(false), - "mouseWheelSensitivity" => s.mouse_wheel_sensitivity = f(1.0).clamp(0.01, 10.0), - "discrete_mouse_scroll" => s.discrete_scroll = b(false), - "toggleCrouch" => s.toggle_crouch = b(false), - "toggleSprint" => s.toggle_sprint = b(false), - "autoJump" => s.auto_jump = b(false), - "lang" => s.language = v.to_owned(), - "forceUnicodeFont" => s.force_unicode = b(false), - "japaneseGlyphVariants" => s.japanese_glyphs = b(false), - "chatVisibility" => s.chat_visibility = v.parse::().unwrap_or(0).min(2), - "chatColors" => s.chat_colors = b(true), - "chatLinks" => s.chat_links = b(true), - "chatOpacity" => s.chat_opacity = f(1.0).clamp(0.0, 1.0), - "textBackgroundOpacity" => s.text_background_opacity = f(0.5).clamp(0.0, 1.0), - "chatScale" => s.chat_scale = f(1.0).clamp(0.0, 1.0), - "chatWidth" => s.chat_width = f(1.0).clamp(0.0, 1.0), - "chatHeightFocused" => s.chat_height_focused = f(1.0).clamp(0.0, 1.0), - "chatHeightUnfocused" => s.chat_height_unfocused = f(0.4375).clamp(0.0, 1.0), - "chatLineSpacing" => s.chat_line_spacing = f(0.0).clamp(0.0, 1.0), - "autoSuggestions" => s.auto_suggestions = b(true), - "reducedDebugInfo" => s.reduced_debug_info = b(false), - "highContrast" => s.high_contrast = b(false), - "mainHand" => s.main_hand_left = unquote(v) == "left", - "resourcePacks" => s.resource_packs = parse_list(v), - _ if k.starts_with("key_") => { - if !s.keys.set_saved(&k[4..], v) { - s.extra.insert(k.to_owned(), v.to_owned()); - } - } - _ if k.starts_with("soundCategory_") => { - let name = &k["soundCategory_".len()..]; - match SOUND_SOURCES.iter().position(|n| *n == name) { - Some(0) => s.master_volume = f(1.0).clamp(0.0, 1.0), - Some(i) => s.volumes[i] = f(1.0).clamp(0.0, 1.0), - None => { - s.extra.insert(k.to_owned(), v.to_owned()); - } - } - } - _ => { - s.extra.insert(k.to_owned(), v.to_owned()); - } - } - } - s + Self::from_file(OptionsFile::parse(text)) } - /// The `options.txt` text (Options.save: `version` first, then key:value). - pub fn serialize(&self) -> String { - let mut lines: Vec<(String, String)> = vec![ - ("ao".into(), self.smooth_lighting.to_string()), - ("biomeBlendRadius".into(), self.biome_blend.to_string()), - ("chunkSectionFadeInTime".into(), self.chunk_fade.to_string()), - ("cutoutLeaves".into(), self.cutout_leaves.to_string()), - ("enableVsync".into(), self.vsync.to_string()), - ( - "entityDistanceScaling".into(), - self.entity_distance.to_string(), - ), - ("entityShadows".into(), self.entity_shadows.to_string()), - ("forceUnicodeFont".into(), self.force_unicode.to_string()), - ( - "japaneseGlyphVariants".into(), - self.japanese_glyphs.to_string(), - ), - ("fov".into(), ((self.fov - 70.0) / 40.0).to_string()), - ( - "graphicsPreset".into(), - format!("\"{}\"", self.graphics_preset), - ), - ( - "prioritizeChunkUpdates".into(), - self.prioritize_chunk_updates.to_string(), - ), - ("fullscreen".into(), self.fullscreen.to_string()), - ("gamma".into(), self.gamma.to_string()), - ("guiScale".into(), self.gui_scale.to_string()), - ("maxFps".into(), self.max_fps.to_string()), - ( - "improvedTransparency".into(), - self.improved_transparency.to_string(), - ), - ( - "inactivityFpsLimit".into(), - format!("\"{}\"", self.inactivity_fps_limit), - ), - ("mipmapLevels".into(), self.mipmap_levels.to_string()), - ("particles".into(), self.particles.to_string()), - ( - "reducedDebugInfo".into(), - self.reduced_debug_info.to_string(), - ), - ("renderClouds".into(), format!("\"{}\"", self.clouds)), - ("cloudRange".into(), self.cloud_range.to_string()), - ("renderDistance".into(), self.render_distance.to_string()), - ( - "simulationDistance".into(), - self.simulation_distance.to_string(), - ), - ("vignette".into(), self.vignette.to_string()), - ("weatherRadius".into(), self.weather_radius.to_string()), - ("autoJump".into(), self.auto_jump.to_string()), - ("autoSuggestions".into(), self.auto_suggestions.to_string()), - ("chatColors".into(), self.chat_colors.to_string()), - ("chatLinks".into(), self.chat_links.to_string()), - ( - "discrete_mouse_scroll".into(), - self.discrete_scroll.to_string(), - ), - ("invertYMouse".into(), self.invert_y.to_string()), - ("bobView".into(), self.view_bobbing.to_string()), - ("toggleCrouch".into(), self.toggle_crouch.to_string()), - ("toggleSprint".into(), self.toggle_sprint.to_string()), - ("mouseSensitivity".into(), self.sensitivity.to_string()), - ("highContrast".into(), self.high_contrast.to_string()), - ( - "resourcePacks".into(), - serde_json::to_string(&self.resource_packs).unwrap_or_else(|_| "[]".into()), - ), - ("lang".into(), self.language.clone()), - ("chatVisibility".into(), self.chat_visibility.to_string()), - ("chatOpacity".into(), self.chat_opacity.to_string()), - ("chatLineSpacing".into(), self.chat_line_spacing.to_string()), - ( - "textBackgroundOpacity".into(), - self.text_background_opacity.to_string(), - ), - ( - "chatHeightFocused".into(), - self.chat_height_focused.to_string(), - ), - ( - "chatHeightUnfocused".into(), - self.chat_height_unfocused.to_string(), - ), - ("chatScale".into(), self.chat_scale.to_string()), - ("chatWidth".into(), self.chat_width.to_string()), - ( - "mainHand".into(), - if self.main_hand_left { - "\"left\"".into() - } else { - "\"right\"".into() - }, - ), - ("attackIndicator".into(), self.attack_indicator.to_string()), - ( - "mouseWheelSensitivity".into(), - self.mouse_wheel_sensitivity.to_string(), - ), - ( - "showAutosaveIndicator".into(), - self.autosave_indicator.to_string(), - ), - ( - "menuBackgroundBlurriness".into(), - self.menu_blur.to_string(), - ), - ]; - for (name, key) in self.keys.saved() { - lines.push((format!("key_{name}"), key)); + /// Typed view of an options file. + pub fn from_file(f: OptionsFile) -> Self { + let mut keys = KeyBinds::default(); + for (name, _, _) in crate::keybinds::MAPPINGS { + keys.set(name, &f.key_binding(name)); } + let mut volumes = [1.0; 11]; + for (i, source) in SOUND_SOURCES.iter().enumerate() { + volumes[i] = f.double(&format!("soundCategory_{source}")) as f32; + } + Self { + fov: f.int("fov") as f32, + render_distance: f.int("renderDistance"), + simulation_distance: f.int("simulationDistance"), + sensitivity: f.double("mouseSensitivity") as f32, + master_volume: volumes[0], + volumes, + gui_scale: f.int("guiScale").max(0) as u32, + view_bobbing: f.bool("bobView"), + gamma: f.double("gamma") as f32, + max_fps: f.int("maxFps") as u32, + vsync: f.bool("enableVsync"), + fullscreen: f.bool("fullscreen"), + smooth_lighting: f.bool("ao"), + clouds: f.name("renderClouds"), + cloud_range: f.int("cloudRange"), + particles: f.int("particles") as u8, + entity_distance: f.double("entityDistanceScaling") as f32, + entity_shadows: f.bool("entityShadows"), + biome_blend: f.int("biomeBlendRadius"), + graphics_preset: f.name("graphicsPreset"), + mipmap_levels: f.int("mipmapLevels"), + weather_radius: f.int("weatherRadius"), + chunk_fade: f.double("chunkSectionFadeInTime") as f32, + vignette: f.bool("vignette"), + autosave_indicator: f.bool("showAutosaveIndicator"), + cutout_leaves: f.bool("cutoutLeaves"), + improved_transparency: f.bool("improvedTransparency"), + attack_indicator: f.int("attackIndicator") as u8, + inactivity_fps_limit: f.name("inactivityFpsLimit"), + prioritize_chunk_updates: f.int("prioritizeChunkUpdates") as u8, + menu_blur: f.int("menuBackgroundBlurriness"), + invert_x: f.bool("invertXMouse"), + invert_y: f.bool("invertYMouse"), + mouse_wheel_sensitivity: f.double("mouseWheelSensitivity") as f32, + discrete_scroll: f.bool("discrete_mouse_scroll"), + toggle_crouch: f.bool("toggleCrouch"), + toggle_sprint: f.bool("toggleSprint"), + toggle_attack: f.bool("toggleAttack"), + toggle_use: f.bool("toggleUse"), + sprint_window: f.int("sprintWindow"), + auto_jump: f.bool("autoJump"), + language: f.string("lang"), + force_unicode: f.bool("forceUnicodeFont"), + japanese_glyphs: f.bool("japaneseGlyphVariants"), + chat_visibility: f.int("chatVisibility") as u8, + chat_colors: f.bool("chatColors"), + chat_links: f.bool("chatLinks"), + chat_opacity: f.double("chatOpacity") as f32, + text_background_opacity: f.double("textBackgroundOpacity") as f32, + chat_scale: f.double("chatScale") as f32, + chat_width: f.double("chatWidth") as f32, + chat_height_focused: f.double("chatHeightFocused") as f32, + chat_height_unfocused: f.double("chatHeightUnfocused") as f32, + chat_line_spacing: f.double("chatLineSpacing") as f32, + auto_suggestions: f.bool("autoSuggestions"), + reduced_debug_info: f.bool("reducedDebugInfo"), + high_contrast: f.bool("highContrast"), + main_hand_left: f.name("mainHand") == "left", + resource_packs: f.list("resourcePacks"), + keys, + file: f, + } + } + /// The options file reflecting the typed fields; values the game did not + /// change keep their stored form. + pub fn to_file(&self) -> OptionsFile { + let mut f = self.file.clone(); + put_i(&mut f, "fov", self.fov as i32); + put_i(&mut f, "renderDistance", self.render_distance); + put_i(&mut f, "simulationDistance", self.simulation_distance); + put_f(&mut f, "mouseSensitivity", self.sensitivity); for (i, source) in SOUND_SOURCES.iter().enumerate() { let v = if i == 0 { self.master_volume } else { self.volumes[i] }; - lines.push((format!("soundCategory_{source}"), v.to_string())); + put_f(&mut f, &format!("soundCategory_{source}"), v); } - let known: std::collections::BTreeSet = - lines.iter().map(|(k, _)| k.clone()).collect(); - for (k, v) in &self.extra { - if !known.contains(k) { - lines.push((k.clone(), v.clone())); - } + put_i(&mut f, "guiScale", self.gui_scale as i32); + put_b(&mut f, "bobView", self.view_bobbing); + put_f(&mut f, "gamma", self.gamma); + put_i(&mut f, "maxFps", self.max_fps as i32); + put_b(&mut f, "enableVsync", self.vsync); + put_b(&mut f, "fullscreen", self.fullscreen); + put_b(&mut f, "ao", self.smooth_lighting); + put_name(&mut f, "renderClouds", &self.clouds); + put_i(&mut f, "cloudRange", self.cloud_range); + put_i(&mut f, "particles", i32::from(self.particles)); + put_f(&mut f, "entityDistanceScaling", self.entity_distance); + put_b(&mut f, "entityShadows", self.entity_shadows); + put_i(&mut f, "biomeBlendRadius", self.biome_blend); + put_name(&mut f, "graphicsPreset", &self.graphics_preset); + put_i(&mut f, "mipmapLevels", self.mipmap_levels); + put_i(&mut f, "weatherRadius", self.weather_radius); + put_f(&mut f, "chunkSectionFadeInTime", self.chunk_fade); + put_b(&mut f, "vignette", self.vignette); + put_b(&mut f, "showAutosaveIndicator", self.autosave_indicator); + put_b(&mut f, "cutoutLeaves", self.cutout_leaves); + put_b(&mut f, "improvedTransparency", self.improved_transparency); + put_i(&mut f, "attackIndicator", i32::from(self.attack_indicator)); + put_name(&mut f, "inactivityFpsLimit", &self.inactivity_fps_limit); + put_i( + &mut f, + "prioritizeChunkUpdates", + i32::from(self.prioritize_chunk_updates), + ); + put_i(&mut f, "menuBackgroundBlurriness", self.menu_blur); + put_b(&mut f, "invertXMouse", self.invert_x); + put_b(&mut f, "invertYMouse", self.invert_y); + put_f( + &mut f, + "mouseWheelSensitivity", + self.mouse_wheel_sensitivity, + ); + put_b(&mut f, "discrete_mouse_scroll", self.discrete_scroll); + put_b(&mut f, "toggleCrouch", self.toggle_crouch); + put_b(&mut f, "toggleSprint", self.toggle_sprint); + put_b(&mut f, "toggleAttack", self.toggle_attack); + put_b(&mut f, "toggleUse", self.toggle_use); + put_i(&mut f, "sprintWindow", self.sprint_window); + put_b(&mut f, "autoJump", self.auto_jump); + put_s(&mut f, "lang", &self.language); + put_b(&mut f, "forceUnicodeFont", self.force_unicode); + put_b(&mut f, "japaneseGlyphVariants", self.japanese_glyphs); + put_i(&mut f, "chatVisibility", i32::from(self.chat_visibility)); + put_b(&mut f, "chatColors", self.chat_colors); + put_b(&mut f, "chatLinks", self.chat_links); + put_f(&mut f, "chatOpacity", self.chat_opacity); + put_f( + &mut f, + "textBackgroundOpacity", + self.text_background_opacity, + ); + put_f(&mut f, "chatScale", self.chat_scale); + put_f(&mut f, "chatWidth", self.chat_width); + put_f(&mut f, "chatHeightFocused", self.chat_height_focused); + put_f(&mut f, "chatHeightUnfocused", self.chat_height_unfocused); + put_f(&mut f, "chatLineSpacing", self.chat_line_spacing); + put_b(&mut f, "autoSuggestions", self.auto_suggestions); + put_b(&mut f, "reducedDebugInfo", self.reduced_debug_info); + put_b(&mut f, "highContrast", self.high_contrast); + put_name( + &mut f, + "mainHand", + if self.main_hand_left { "left" } else { "right" }, + ); + if self.resource_packs != f.list("resourcePacks") { + f.set("resourcePacks", V::List(self.resource_packs.clone())); } - let mut out = format!("version:{}\n", horizon_world::DATA_VERSION); - for (k, v) in lines { - out.push_str(&format!("{k}:{v}\n")); + for (name, key) in self.keys.saved() { + put_s(&mut f, &format!("key_{name}"), &key); } - out + f + } + /// The `options.txt` text (Options.save). + pub fn serialize(&self) -> String { + self.to_file().serialize() } pub fn save(&self, path: &Path) { let _ = fs::write(path, self.serialize()); @@ -520,7 +488,8 @@ mod tests { let out = s.serialize(); assert!(out.starts_with("version:")); assert!(out.contains("\nkey_key.jump:key.keyboard.j\n")); - assert!(out.contains("\nsomeFutureOption:42\n")); + // Options.save writes only the options it knows. + assert!(!out.contains("someFutureOption")); assert!(out.contains("\nrenderClouds:\"fast\"\n")); let again = Settings::parse(&out); assert_eq!(again.fov, 90.0); diff --git a/crates/horizon-client/src/window.rs b/crates/horizon-client/src/window.rs new file mode 100644 index 000000000..d5d0d0c2d --- /dev/null +++ b/crates/horizon-client/src/window.rs @@ -0,0 +1,226 @@ +//! Window sizing and frame pacing of 26.3: `Window.calculateScale` and +//! `setGuiScale`, `MouseHandler`'s scaled positions, `FramerateLimitTracker`, +//! `FramerateLimiter` and the vsync present-mode choice. + +/// `Window.calculateScale`: the largest scale that leaves at least 320x240 +/// GUI pixels, capped by `max_scale` (0 = automatic); an odd result is bumped +/// to even when unicode is enforced. +pub fn calculate_scale(framebuffer: [i32; 2], max_scale: i32, enforce_unicode: bool) -> i32 { + let [width, height] = framebuffer; + let mut scale = 1; + while scale != max_scale + && scale < width + && scale < height + && width / (scale + 1) >= 320 + && height / (scale + 1) >= 240 + { + scale += 1; + } + if enforce_unicode && scale % 2 != 0 { + scale += 1; + } + scale +} + +/// `Window.setGuiScale`: the GUI-scaled size of a framebuffer. +pub fn gui_scaled_size(framebuffer: [i32; 2], gui_scale: i32) -> [i32; 2] { + let scaled = |v: i32| (f64::from(v) / f64::from(gui_scale)).ceil() as i32; + [scaled(framebuffer[0]), scaled(framebuffer[1])] +} + +/// `MouseHandler.getScaledXPos`/`getScaledYPos`. +pub fn scaled_pos(pos: f64, gui_scaled: i32, screen: i32) -> f64 { + pos * f64::from(gui_scaled) / f64::from(screen) +} + +/// `InactivityFpsLimit`. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum InactivityFpsLimit { + Minimized, + Afk, +} + +/// `FramerateLimitTracker.FramerateThrottleReason`. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum ThrottleReason { + None, + WindowIconified, + LongAfk, + ShortAfk, + OutOfLevelMenu, +} + +/// What `FramerateLimitTracker` looks at. +#[derive(Clone, Copy, Debug)] +pub struct FrameContext { + pub inactivity: InactivityFpsLimit, + pub iconified: bool, + pub focused: bool, + pub exclusive_fullscreen: bool, + pub now_ms: i64, + pub latest_input_ms: i64, + pub has_level: bool, + pub has_screen: bool, + pub has_overlay: bool, +} + +/// `getThrottleReason`. +pub fn throttle_reason(c: FrameContext) -> ThrottleReason { + if !c.iconified && (c.focused || !c.exclusive_fullscreen) { + if c.inactivity == InactivityFpsLimit::Afk { + let afk = c.now_ms - c.latest_input_ms; + if afk > 600_000 { + return ThrottleReason::LongAfk; + } + if afk > 60_000 { + return ThrottleReason::ShortAfk; + } + } + if c.has_level || (!c.has_screen && !c.has_overlay) { + ThrottleReason::None + } else { + ThrottleReason::OutOfLevelMenu + } + } else { + ThrottleReason::WindowIconified + } +} + +/// `getFramerateLimit`. +pub fn framerate_limit(option_limit: i32, c: FrameContext) -> i32 { + match throttle_reason(c) { + ThrottleReason::None => option_limit, + ThrottleReason::WindowIconified | ThrottleReason::LongAfk => 10, + ThrottleReason::ShortAfk => option_limit.min(30), + ThrottleReason::OutOfLevelMenu => 60, + } +} + +/// `isHeavilyThrottled`. +pub fn heavily_throttled(reason: ThrottleReason) -> bool { + matches!(reason, ThrottleReason::WindowIconified | ThrottleReason::LongAfk) +} + +/// Present modes the renderer can choose between. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum PresentMode { + Fifo, + Mailbox, + Immediate, +} + +/// `GpuSurface.PresentMode.getSupportedVsyncMode`: vsync means Fifo only, +/// otherwise the first of Immediate, Mailbox, Fifo that is supported. +pub fn vsync_present_mode(supported: &[PresentMode], vsync: bool) -> Option { + let preferred: &[PresentMode] = if vsync { + &[PresentMode::Fifo] + } else { + &[PresentMode::Immediate, PresentMode::Mailbox, PresentMode::Fifo] + }; + preferred.iter().copied().find(|m| supported.contains(m)) +} + +/// `FramerateLimiter.limitDisplayFPS` with an injectable clock so the sleep +/// and spin decisions are testable. +#[derive(Clone, Debug)] +pub struct FramerateLimiter { + last_frame_time: i64, + average_overshoot_ns: i64, + last_framerate_limit: i32, +} + +/// Time source of the limiter. +pub trait LimiterClock { + fn nanos(&mut self) -> i64; + /// `LockSupport.parkNanos`. + fn park(&mut self, nanos: i64); + /// `Thread.onSpinWait`. + fn spin(&mut self); +} + +impl FramerateLimiter { + pub fn new(now_ns: i64) -> Self { + Self { + last_frame_time: now_ns, + average_overshoot_ns: 0, + last_framerate_limit: 0, + } + } + pub fn limit_display_fps(&mut self, framerate_limit: i32, clock: &mut impl LimiterClock) { + let target_time_per_frame = 1_000_000_000 / i64::from(framerate_limit); + let target_time_ns = self.last_frame_time + target_time_per_frame; + if framerate_limit != self.last_framerate_limit { + self.average_overshoot_ns = 0; + self.last_framerate_limit = framerate_limit; + } + loop { + let remaining = target_time_ns - clock.nanos(); + if remaining <= 0 { + break; + } + if remaining > self.average_overshoot_ns + 500_000 { + let sleep_start = clock.nanos(); + let expected = remaining - self.average_overshoot_ns - 500_000; + clock.park(expected); + let duration = clock.nanos() - sleep_start; + let overshoot = duration - expected; + if overshoot > 0 && overshoot < 25_000_000 { + self.average_overshoot_ns = + (0.1 * overshoot as f64 + 0.9 * self.average_overshoot_ns as f64) as i64; + self.average_overshoot_ns = self.average_overshoot_ns.min(2_000_000); + } + } else { + clock.spin(); + } + } + self.last_frame_time = clock.nanos(); + } + pub fn last_frame_time(&self) -> i64 { + self.last_frame_time + } +} + +#[cfg(test)] +mod tests { + use super::*; + + struct Virtual { + now: i64, + oversleep: i64, + } + impl LimiterClock for Virtual { + fn nanos(&mut self) -> i64 { + self.now + } + fn park(&mut self, nanos: i64) { + self.now += nanos + self.oversleep; + } + fn spin(&mut self) { + self.now += 1000; + } + } + + #[test] + fn scale_matches_the_320_by_240_rule() { + assert_eq!(calculate_scale([854, 480], 0, false), 2); + assert_eq!(calculate_scale([1920, 1080], 0, false), 4); + assert_eq!(calculate_scale([1920, 1080], 3, false), 3); + assert_eq!(calculate_scale([1920, 1080], 3, true), 4); + assert_eq!(gui_scaled_size([1921, 1081], 4), [481, 271]); + } + #[test] + fn limiter_paces_frames_at_the_target() { + let mut limiter = FramerateLimiter::new(0); + let mut clock = Virtual { now: 1_000_000, oversleep: 200_000 }; + limiter.limit_display_fps(100, &mut clock); + assert!(clock.now >= 10_000_000); + assert!(clock.now < 10_000_000 + 1_000_000); + } + #[test] + fn vsync_only_uses_fifo() { + let all = [PresentMode::Mailbox, PresentMode::Fifo, PresentMode::Immediate]; + assert_eq!(vsync_present_mode(&all, true), Some(PresentMode::Fifo)); + assert_eq!(vsync_present_mode(&all, false), Some(PresentMode::Immediate)); + assert_eq!(vsync_present_mode(&[PresentMode::Fifo], false), Some(PresentMode::Fifo)); + } +} diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaGameLoopOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaGameLoopOracle.java new file mode 100644 index 000000000..0be89888a --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaGameLoopOracle.java @@ -0,0 +1,377 @@ +package dev.horizonlab.parity; + +import com.google.gson.*; +import com.mojang.blaze3d.platform.FramerateLimitTracker; +import com.mojang.blaze3d.platform.InputConstants; +import com.mojang.blaze3d.platform.Window; +import java.io.*; +import java.lang.reflect.*; +import java.nio.charset.StandardCharsets; +import java.nio.file.*; +import java.util.*; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.function.*; +import net.minecraft.client.*; +import net.minecraft.client.gui.Gui; +import net.minecraft.client.player.LocalPlayer; +import net.minecraft.client.tutorial.Tutorial; +import net.minecraft.commands.CommandSourceStack; +import net.minecraft.network.chat.Component; +import net.minecraft.network.chat.contents.TranslatableContents; +import net.minecraft.server.MinecraftServer; +import net.minecraft.server.ServerTickRateManager; +import net.minecraft.server.players.PlayerList; +import net.minecraft.world.entity.player.Input; +import net.minecraft.world.entity.player.Inventory; + +/** + * Drives the real DeltaTracker.Timer, ServerTickRateManager, Window.calculateScale, + * FramerateLimitTracker, MouseHandler (move, scroll, turnPlayer), Entity.turn and + * ToggleKeyMapping with the input sequences in a JSON-lines file and prints + * every observable bit-exactly. Hosts are uninitialised shells (Unsafe) that + * carry only the fields the exercised code reads. + */ +public final class VanillaGameLoopOracle { + static Object unsafe; + static Method allocate; + + @SuppressWarnings("unchecked") + static T make(Class type) throws Exception { + return (T) allocate.invoke(unsafe, type); + } + + static Field field(Class type, String name) throws Exception { + Field f = type.getDeclaredField(name); + f.setAccessible(true); + return f; + } + + static float f(JsonElement v) { + return Float.intBitsToFloat(Integer.parseUnsignedInt(v.getAsString(), 16)); + } + + static double d(JsonElement v) { + return Double.longBitsToDouble(Long.parseUnsignedLong(v.getAsString(), 16)); + } + + static String fb(float v) { + return String.format("%08x", Float.floatToRawIntBits(v) == 0x7fc00000 || Float.isNaN(v) ? 0x7fc00000 : Float.floatToRawIntBits(v)); + } + + static String db(double v) { + return String.format("%016x", Double.isNaN(v) ? 0x7ff8000000000000L : Double.doubleToRawLongBits(v)); + } + + // ---- stubs for the server tick manager ------------------------------------------------- + static final List reports = new ArrayList<>(); + + static final class StubStack extends CommandSourceStack { + StubStack() { + super(null, null, null, null, null, (Component) null, null); + } + + @Override + public void sendSuccess(Supplier message, boolean broadcast) { + var contents = (TranslatableContents) message.get().getContents(); + reports.add(contents.getArgs()[0] + " " + contents.getArgs()[1]); + } + } + + static final class StubPlayers extends PlayerList { + StubPlayers() { + super(null, null, null, (net.minecraft.server.notifications.NotificationService) null); + } + + @Override + public void broadcastAll(net.minecraft.network.protocol.Packet packet) { + } + } + + static StubStack stubStack; + static StubPlayers stubPlayers; + + static final class StubServer extends MinecraftServer { + StubServer() { + super(null, null, null, null, null, null, null, null, null, false, null); + } + + @Override public PlayerList getPlayerList() { return stubPlayers; } + @Override public CommandSourceStack createCommandSourceStack() { return stubStack; } + @Override public void onTickRateChanged() { } + @Override protected boolean initServer() { return false; } + @Override public net.minecraft.server.permissions.LevelBasedPermissionSet operatorUserPermissions() { return null; } + @Override public net.minecraft.server.permissions.PermissionSet getFunctionCompilationPermissions() { return null; } + @Override public boolean shouldRconBroadcast() { return false; } + @Override protected net.minecraft.util.debugchart.SampleLogger getTickTimeLogger() { return null; } + @Override public boolean isTickTimeLoggingEnabled() { return false; } + @Override public net.minecraft.SystemReport fillServerSystemReport(net.minecraft.SystemReport r) { return r; } + @Override public boolean isDedicatedServer() { return false; } + @Override public int getRateLimitPacketsPerSecond() { return 0; } + @Override public int getCommandSpamThresholdSeconds() { return 0; } + @Override public int getChatSpamThresholdSeconds() { return 0; } + @Override public boolean useNativeTransport() { return false; } + @Override public boolean isPublished() { return false; } + @Override public int getMaxPlayers() { return 0; } + @Override public boolean shouldInformAdmins() { return false; } + @Override public boolean isSingleplayerOwner(net.minecraft.server.players.NameAndId id) { return false; } + } + + static final class StubPlayer extends LocalPlayer { + boolean scoping; + + StubPlayer() { + super(null, null, null, null, null, Input.EMPTY, false, null, null); + } + + @Override public boolean isScoping() { return scoping; } + @Override public boolean isSpectator() { return false; } + } + + static Minecraft shell; + static Options options; + + public static void main(String[] args) throws Exception { + net.minecraft.SharedConstants.tryDetectVersion(); + net.minecraft.server.Bootstrap.bootStrap(); + var u = Class.forName("sun.misc.Unsafe"); + unsafe = field(u, "theUnsafe").get(null); + allocate = u.getMethod("allocateInstance", Class.class); + shell = make(Minecraft.class); + field(Minecraft.class, "fixerUpper").set(shell, net.minecraft.util.datafix.DataFixers.getDataFixer()); + field(Minecraft.class, "instance").set(null, shell); + options = new Options(shell, Files.createTempDirectory("opts").toFile()); + stubStack = make(StubStack.class); + stubPlayers = make(StubPlayers.class); + try (var out = new PrintWriter(Files.newBufferedWriter(Path.of(args[1]), StandardCharsets.UTF_8)); + var lines = Files.lines(Path.of(args[0]))) { + for (var line : (Iterable) lines::iterator) { + var c = JsonParser.parseString(line).getAsJsonObject(); + switch (c.get("t").getAsString()) { + case "timer" -> timer(c, out); + case "rate" -> rate(c, out); + case "scale" -> scale(c, out); + case "limit" -> limit(c, out); + case "mouse" -> mouse(c, out); + case "scroll" -> scroll(c, out); + case "key" -> key(c, out); + default -> throw new IllegalArgumentException(line); + } + } + } + System.exit(0); + } + + static void timer(JsonObject c, PrintWriter out) { + float[] mspt = {0}; + var timer = new DeltaTracker.Timer(f(c.get("tps")), c.get("start").getAsLong(), + d -> mspt[0] == 0 ? d : Math.max(d, mspt[0])); + out.println("timer"); + for (var e : c.getAsJsonArray("ops")) { + var op = e.getAsJsonArray(); + String name = op.get(0).getAsString(); + String result = ""; + switch (name) { + case "adv" -> { + mspt[0] = op.get(2).isJsonNull() ? 0 : f(op.get(2)); + result = " " + timer.advanceGameTime(op.get(1).getAsLong()); + } + case "real" -> timer.advanceRealTime(op.get(1).getAsLong()); + case "pause" -> timer.updatePauseState(op.get(1).getAsBoolean()); + case "frozen" -> timer.updateFrozenState(op.get(1).getAsBoolean()); + default -> throw new IllegalArgumentException(name); + } + out.println(name + result + " " + fb(timer.getGameTimeDeltaTicks()) + " " + fb(timer.getGameTimeDeltaPartialTick(false)) + + " " + fb(timer.getGameTimeDeltaPartialTick(true)) + " " + fb(timer.getRealtimeDeltaTicks())); + } + } + + static void rate(JsonObject c, PrintWriter out) throws Exception { + var m = make(ServerTickRateManager.class); + field(ServerTickRateManager.class, "server").set(m, make(StubServer.class)); + // Field initialisers do not run on a shell. + field(net.minecraft.world.TickRateManager.class, "tickrate").setFloat(m, 20.0F); + field(net.minecraft.world.TickRateManager.class, "nanosecondsPerTick").setLong(m, 50_000_000L); + field(net.minecraft.world.TickRateManager.class, "runGameElements").setBoolean(m, true); + var startTime = field(ServerTickRateManager.class, "sprintTickStartTime"); + var spend = field(ServerTickRateManager.class, "sprintTimeSpend"); + out.println("rate"); + for (var e : c.getAsJsonArray("ops")) { + var op = e.getAsJsonArray(); + String name = op.get(0).getAsString(); + reports.clear(); + String result = ""; + switch (name) { + case "rate" -> m.setTickRate(f(op.get(1))); + case "freeze" -> m.setFrozen(op.get(1).getAsBoolean()); + case "step" -> result = " " + m.stepGameIfPaused(op.get(1).getAsInt()); + case "stopstep" -> result = " " + m.stopStepping(); + case "sprint" -> result = " " + m.requestGameToSprint(op.get(1).getAsInt()); + case "check" -> { + result = " " + m.checkShouldSprintThisTick(); + if (m.runsNormally() && result.equals(" true")) { + startTime.setLong(m, op.get(1).getAsLong()); + } else if (m.runsNormally() && reports.isEmpty()) { + // unreachable: the else branch always reports + } + } + case "end" -> { + long before = spend.getLong(m); + m.endTickWork(); + spend.setLong(m, before + (op.get(1).getAsLong() - startTime.getLong(m))); + } + case "stopsprint" -> result = " " + m.stopSprinting(); + case "tick" -> m.tick(); + default -> throw new IllegalArgumentException(name); + } + out.println(name + result + " | " + fb(m.tickrate()) + " " + m.nanosecondsPerTick() + " " + fb(m.millisecondsPerTick()) + + " " + m.runsNormally() + " " + m.isSteppingForward() + " " + m.frozenTicksToRun() + " " + m.isFrozen() + + " " + m.isSprinting() + (reports.isEmpty() ? "" : " report " + reports.get(0))); + } + } + + static Window window(int w, int h, int sw, int sh) throws Exception { + Window window = make(Window.class); + field(Window.class, "framebufferWidth").setInt(window, w); + field(Window.class, "framebufferHeight").setInt(window, h); + field(Window.class, "width").setInt(window, sw); + field(Window.class, "height").setInt(window, sh); + return window; + } + + static void scale(JsonObject c, PrintWriter out) throws Exception { + Window window = window(c.get("w").getAsInt(), c.get("h").getAsInt(), c.get("sw").getAsInt(), c.get("sh").getAsInt()); + int scale = window.calculateScale(c.get("max").getAsInt(), c.get("uni").getAsBoolean()); + window.setGuiScale(scale); + out.println("scale " + scale + " " + window.getGuiScaledWidth() + " " + window.getGuiScaledHeight() + " " + + db(MouseHandler.getScaledXPos(window, d(c.get("x")))) + " " + db(MouseHandler.getScaledYPos(window, d(c.get("y"))))); + } + + static void limit(JsonObject c, PrintWriter out) throws Exception { + Window window = window(1, 1, 1, 1); + field(Window.class, "iconified").setBoolean(window, c.get("iconified").getAsBoolean()); + field(Window.class, "focused").setBoolean(window, c.get("focused").getAsBoolean()); + Minecraft mc = make(Minecraft.class); + field(Minecraft.class, "window").set(mc, window); + Gui gui = make(Gui.class); + field(Gui.class, "screen").set(gui, c.get("screen").getAsBoolean() ? make(net.minecraft.client.gui.screens.PauseScreen.class) : null); + field(Gui.class, "overlay").set(gui, c.get("overlay").getAsBoolean() ? make(net.minecraft.client.gui.screens.LoadingOverlay.class) : null); + field(Minecraft.class, "gui").set(mc, gui); + field(Minecraft.class, "level").set(mc, c.get("level").getAsBoolean() ? make(net.minecraft.client.multiplayer.ClientLevel.class) : null); + options.framerateLimit().set(c.get("opt").getAsInt()); + options.inactivityFpsLimit().set(c.get("afk").getAsBoolean() ? InactivityFpsLimit.AFK : InactivityFpsLimit.MINIMIZED); + var tracker = new FramerateLimitTracker(options, mc); + field(FramerateLimitTracker.class, "latestInputTime").setLong(tracker, net.minecraft.util.Util.getMillis() - c.get("ago").getAsLong()); + out.println("limit " + tracker.getThrottleReason() + " " + tracker.getFramerateLimit() + " " + tracker.isHeavilyThrottled()); + } + + static MouseHandler handler(Minecraft mc) throws Exception { + MouseHandler h = new MouseHandler(mc); + return h; + } + + static void mouse(JsonObject c, PrintWriter out) throws Exception { + Window window = window(1, 1, 1, 1); + field(Window.class, "handle").setLong(window, 1L); + field(Window.class, "focused").setBoolean(window, c.get("active").getAsBoolean()); + Minecraft mc = make(Minecraft.class); + field(Minecraft.class, "window").set(mc, window); + field(Minecraft.class, "options").set(mc, options); + field(Minecraft.class, "framerateLimitTracker").set(mc, make(FramerateLimitTracker.class)); + field(Minecraft.class, "tutorial").set(mc, make(Tutorial.class)); + StubPlayer player = make(StubPlayer.class); + player.scoping = c.get("scoping").getAsBoolean(); + mc.player = player; + options.sensitivity().set(d(c.get("sens"))); + options.smoothCamera = c.get("smooth").getAsBoolean(); + options.invertMouseX().set(c.get("ix").getAsBoolean()); + options.invertMouseY().set(c.get("iy").getAsBoolean()); + MouseHandler h = handler(mc); + field(MouseHandler.class, "mouseGrabbed").setBoolean(h, c.get("grabbed").getAsBoolean()); + var turn = MouseHandler.class.getDeclaredMethod("turnPlayer", double.class); + turn.setAccessible(true); + var dx = field(MouseHandler.class, "accumulatedDX"); + var dy = field(MouseHandler.class, "accumulatedDY"); + double last = Double.MIN_VALUE; + out.println("mouse"); + for (var e : c.getAsJsonArray("ops")) { + var op = e.getAsJsonArray(); + switch (op.get(0).getAsString()) { + case "move" -> h.onMove(1L, d(op.get(1)), d(op.get(2)), d(op.get(3)), d(op.get(4))); + case "ignore" -> h.setIgnoreFirstMove(); + case "frame" -> { + double time = d(op.get(1)); + double mousea = time - last; + last = time; + // MouseHandler.handleAccumulatedMovement without the SDL clock and screens. + if (mc.isWindowActive() && h.isMouseGrabbed() && mc.player != null) { + turn.invoke(h, mousea); + } + dx.setDouble(h, 0.0); + dy.setDouble(h, 0.0); + out.println("frame " + fb(player.getXRot()) + " " + fb(player.getYRot()) + " " + + fb(player.xRotO) + " " + fb(player.yRotO)); + } + default -> throw new IllegalArgumentException(op.toString()); + } + } + } + + static void scroll(JsonObject c, PrintWriter out) throws Exception { + Window window = window(1, 1, 1, 1); + field(Window.class, "handle").setLong(window, 1L); + Minecraft mc = make(Minecraft.class); + field(Minecraft.class, "window").set(mc, window); + field(Minecraft.class, "options").set(mc, options); + field(Minecraft.class, "framerateLimitTracker").set(mc, make(FramerateLimitTracker.class)); + field(Minecraft.class, "gui").set(mc, make(Gui.class)); + StubPlayer player = make(StubPlayer.class); + Inventory inventory = make(Inventory.class); + inventory.setSelectedSlot(c.get("slot").getAsInt()); + field(net.minecraft.world.entity.player.Player.class, "inventory").set(player, inventory); + mc.player = player; + options.discreteMouseScroll().set(c.get("discrete").getAsBoolean()); + options.mouseWheelSensitivity().set(d(c.get("sens"))); + MouseHandler h = handler(mc); + out.println("scroll"); + for (var e : c.getAsJsonArray("ops")) { + var op = e.getAsJsonArray(); + h.onScroll(1L, d(op.get(0)), d(op.get(1))); + out.println(inventory.getSelectedSlot()); + } + } + + static int keys = 0; + + static void key(JsonObject c, PrintWriter out) throws Exception { + AtomicBoolean option = new AtomicBoolean(); + int value = 10000 + keys++; + KeyMapping mapping = c.get("toggle").getAsBoolean() + ? new ToggleKeyMapping("key.test" + value, c.get("keyboard").getAsBoolean() ? InputConstants.Type.KEYBOARD : InputConstants.Type.MOUSE, + value, KeyMapping.Category.MISC, option::get, c.get("restore").getAsBoolean()) + : new KeyMapping("key.test" + value, InputConstants.Type.KEYBOARD, value, KeyMapping.Category.MISC); + var release = KeyMapping.class.getDeclaredMethod("release"); + release.setAccessible(true); + var key = c.get("toggle").getAsBoolean() && !c.get("keyboard").getAsBoolean() + ? InputConstants.Type.MOUSE.getOrCreate(value) : InputConstants.Type.KEYBOARD.getOrCreate(value); + out.println("key"); + for (var e : c.getAsJsonArray("ops")) { + var op = e.getAsJsonArray(); + String result = ""; + switch (op.get(0).getAsString()) { + case "option" -> option.set(op.get(1).getAsBoolean()); + case "down" -> mapping.setDown(op.get(1).getAsBoolean()); + case "release" -> release.invoke(mapping); + case "restore" -> result = mapping instanceof ToggleKeyMapping t ? " " + t.shouldRestoreStateOnScreenClosed() : " false"; + case "click" -> KeyMapping.click(key); + case "consume" -> result = " " + mapping.consumeClick(); + case "ingame" -> { + var m = KeyMapping.class.getDeclaredMethod("shouldSetOnIngameFocus"); + m.setAccessible(true); + result = " " + m.invoke(mapping); + } + default -> throw new IllegalArgumentException(op.toString()); + } + out.println(op.get(0).getAsString() + result + " " + mapping.isDown()); + } + } +} diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaOptionsOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaOptionsOracle.java new file mode 100644 index 000000000..7e8215ffb --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaOptionsOracle.java @@ -0,0 +1,63 @@ +package dev.horizonlab.parity; + +import java.io.*; +import java.lang.reflect.*; +import java.nio.charset.StandardCharsets; +import java.nio.file.*; +import java.util.*; +import net.minecraft.client.*; +import net.minecraft.util.datafix.DataFixers; + +/** + * Loads each options.txt case through the real Options.load and writes it back + * with Options.save, then dumps the key mapping table (order, defaults, + * categories). The Minecraft instance is an uninitialised shell that only + * supplies the data fixer. + */ +public final class VanillaOptionsOracle { + public static void main(String[] args) throws Exception { + net.minecraft.SharedConstants.tryDetectVersion(); + net.minecraft.server.Bootstrap.bootStrap(); + var u = Class.forName("sun.misc.Unsafe"); + var uf = u.getDeclaredField("theUnsafe"); + uf.setAccessible(true); + Object unsafe = uf.get(null); + var allocate = u.getMethod("allocateInstance", Class.class); + Minecraft shell = (Minecraft) allocate.invoke(unsafe, Minecraft.class); + Field fixer = Minecraft.class.getDeclaredField("fixerUpper"); + fixer.setAccessible(true); + fixer.set(shell, DataFixers.getDataFixer()); + Field instance = Minecraft.class.getDeclaredField("instance"); + instance.setAccessible(true); + instance.set(null, shell); + Path cases = Path.of(args[0]); + Path work = Files.createTempDirectory("opts"); + List files = new ArrayList<>(); + try (var s = Files.list(cases)) { + s.sorted().forEach(files::add); + } + try (var out = new PrintWriter(Files.newBufferedWriter(Path.of(args[1]), StandardCharsets.UTF_8))) { + boolean first = true; + for (Path file : files) { + Path target = work.resolve("options.txt"); + Files.deleteIfExists(target); + if (!file.getFileName().toString().equals("absent.txt")) { + Files.copy(file, target); + } + Options options = new Options(shell, work.toFile()); + options.save(); + out.print("== " + file.getFileName() + "\n"); + out.print(Files.readString(target, StandardCharsets.UTF_8)); + if (first) { + first = false; + out.print("== keys\n"); + for (KeyMapping k : options.keyMappings) { + out.print(k.getName() + " " + k.getDefaultKey().getName() + " " + k.getCategory().id().getPath() + " " + + (k instanceof ToggleKeyMapping) + "\n"); + } + } + } + } + System.exit(0); + } +} diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaOptionsTableExporter.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaOptionsTableExporter.java new file mode 100644 index 000000000..00b34b33c --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaOptionsTableExporter.java @@ -0,0 +1,119 @@ +package dev.horizonlab.parity; + +import com.google.gson.*; +import com.mojang.serialization.JsonOps; +import java.io.*; +import java.lang.reflect.*; +import java.nio.charset.StandardCharsets; +import java.nio.file.*; +import java.util.*; +import java.util.function.*; +import net.minecraft.client.*; +import net.minecraft.util.datafix.DataFixers; + +/** + * Dumps Options.processOptions as a table: key, kind and default in processing + * order. Used to (re)generate the Rust options table; the differential harness + * then proves the Rust port agrees on loading and saving. + */ +public final class VanillaOptionsTableExporter { + public static void main(String[] args) throws Exception { + net.minecraft.SharedConstants.tryDetectVersion(); + net.minecraft.server.Bootstrap.bootStrap(); + var u = Class.forName("sun.misc.Unsafe"); + var uf = u.getDeclaredField("theUnsafe"); + uf.setAccessible(true); + Object unsafe = uf.get(null); + var allocate = u.getMethod("allocateInstance", Class.class); + Minecraft shell = (Minecraft) allocate.invoke(unsafe, Minecraft.class); + Field instance = Minecraft.class.getDeclaredField("instance"); + instance.setAccessible(true); + instance.set(null, shell); + Path work = Files.createTempDirectory("opts"); + Options options = new Options(shell, work.toFile()); + Method process = Options.class.getDeclaredMethod("processOptions", Class.forName("net.minecraft.client.Options$FieldAccess")); + process.setAccessible(true); + Field valuesField = OptionInstance.class.getDeclaredField("values"); + valuesField.setAccessible(true); + Gson gson = new Gson(); + try (var out = new PrintWriter(Files.newBufferedWriter(Path.of(args[0]), StandardCharsets.UTF_8))) { + Class fa = Class.forName("net.minecraft.client.Options$FieldAccess"); + Object access = Proxy.newProxyInstance(fa.getClassLoader(), new Class[]{fa}, (proxy, method, a) -> { + String name = (String) a[0]; + Class rt = method.getReturnType(); + if (a.length == 2 && a[1] instanceof OptionInstance oi) { + Object vs = valuesField.get(oi); + var encoded = ((OptionInstance) oi).codec().encodeStart(JsonOps.INSTANCE, oi.get()).result().orElse(null); + if (vs instanceof OptionInstance.Enum en) { + StringBuilder sb = new StringBuilder(); + for (Object v : en.values()) { + sb.append(gson.toJson(((com.mojang.serialization.Codec) en.codec()).encodeStart(JsonOps.INSTANCE, v).result().orElse(null))).append(','); + } + out.println("enum " + name + " " + sb); + } + if (vs instanceof OptionInstance.SliderableEnum en) { + StringBuilder sb = new StringBuilder(); + for (Object v : en.values()) { + sb.append(gson.toJson(((com.mojang.serialization.Codec) en.codec()).encodeStart(JsonOps.INSTANCE, v).result().orElse(null))).append(','); + } + out.println("enum " + name + " " + sb); + } + out.println("option " + name + " " + vs.getClass().getSimpleName() + " " + describe(vs) + " => " + gson.toJson(encoded)); + return null; + } + if (a.length == 2) { + out.println("plain " + name + " " + rt.getSimpleName() + " => " + a[1]); + return a[1]; + } + if (a.length == 4) { + Object conv = ((Function) a[3]).apply(a[1]); + out.println("custom " + name + " => " + conv); + return a[1]; + } + return null; + }); + process.invoke(options, access); + } + try (var out = new PrintWriter(Files.newBufferedWriter(Path.of(args[1]), StandardCharsets.UTF_8))) { + Field map = com.mojang.blaze3d.platform.InputConstants.Type.class.getDeclaredField("map"); + map.setAccessible(true); + for (var type : com.mojang.blaze3d.platform.InputConstants.Type.values()) { + var m = (it.unimi.dsi.fastutil.ints.Int2ObjectMap) map.get(type); + var entries = new TreeMap(); + for (var e : m.int2ObjectEntrySet()) { + entries.put(e.getIntKey(), e.getValue().getName()); + } + for (var e : entries.entrySet()) { + out.println(type.name().toLowerCase() + " " + e.getKey() + " " + e.getValue()); + } + } + } + System.exit(0); + } + + static String describe(Object vs) throws Exception { + if (vs instanceof Record r) { + StringBuilder sb = new StringBuilder("{"); + for (var c : r.getClass().getRecordComponents()) { + Object v = c.getAccessor().invoke(r); + String s = String.valueOf(v); + if (v instanceof List l) { + s = l.toString(); + } else if (v != null && s.contains("$$Lambda")) { + s = ""; + } + if (c.getName().equals("codec") || c.getName().equals("valueSetter") || c.getName().equals("altCondition") + || c.getName().equals("validateValue") || c.getName().equals("maxSupplier") || c.getName().equals("values") && !(v instanceof List)) { + if (c.getName().equals("maxSupplier")) { + s = ""; + } else if (!c.getName().equals("values")) { + s = ""; + } + } + sb.append(c.getName()).append('=').append(s).append(' '); + } + return sb.append('}').toString(); + } + return vs.toString(); + } +} diff --git a/tools/oracle_harness.py b/tools/oracle_harness.py new file mode 100644 index 000000000..a19b5ba94 --- /dev/null +++ b/tools/oracle_harness.py @@ -0,0 +1,118 @@ +"""Shared plumbing for single-oracle differential harnesses. + +A harness supplies a Java oracle (compiled against the pinned client jar and its +libraries), a Rust example probe, and a text input; both programs write one +result line per input line and the outputs must be byte-identical.""" +import os +from pathlib import Path +import subprocess + +try: + from . import lab, test_rust_parity as base, test_model_baking_parity as baking +except ImportError: + import lab, test_rust_parity as base, test_model_baking_parity as baking + + +def run_logged(command, build, name, timeout=900, **kwargs): + with (build / (name + '.log')).open('w') as log: + subprocess.run([str(c) for c in command], cwd=lab.ROOT, check=True, timeout=timeout, + stdout=log, stderr=subprocess.STDOUT, **kwargs) + + +def compile_oracle(build, oracle_name, jars, libraries, java_major): + oracle = lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity' / (oracle_name + '.java') + classes = build / 'classes' + classes.mkdir(parents=True, exist_ok=True) + dependencies = os.pathsep.join(map(str, [jars['client'], *libraries])) + run_logged(['javac', '--release', java_major, '-proc:none', '-sourcepath', + lab.ROOT / 'mods/horizon/src/test/java', '-cp', dependencies, '-d', classes, oracle], + build, 'compile-java-' + oracle_name) + return classes, dependencies, oracle + + +def build_probe(build, example): + run_logged(['cargo', 'build', '--locked', '-p', 'horizon-client', '--example', example], + build, 'compile-rust-' + example, env=dict(os.environ, CARGO_BUILD_JOBS='3')) + import json + metadata = json.loads(subprocess.check_output( + ['cargo', 'metadata', '--locked', '--no-deps', '--format-version', '1'], cwd=lab.ROOT)) + return Path(metadata['target_directory']) / 'debug/examples' / example + + +def java_run(build, classes, dependencies, main_class, args, name, jvm=()): + run_logged(['java', '-Xmx2g', '-Djava.awt.headless=true', *jvm, '-cp', str(classes) + os.pathsep + dependencies, + 'dev.horizonlab.parity.' + main_class, *args], build, name) + + +def compare(client_out, rust_out, expected_lines): + matched = base.compare(client_out, rust_out) + if matched != expected_lines: + raise AssertionError(f'Incomplete output: {matched} of {expected_lines} lines') + return matched + + +def differential(name, oracle, probe, make_input, scope, sources=(), expected_lines=None): + """Compile the oracle and probe, run both on one input and require identical output.""" + import platform + lock, jars, libraries = base.verify_artifacts() + libraries = baking.client_libraries() + build = lab.LOCAL / name + build.mkdir(exist_ok=True) + report = build / 'report.json' + report.unlink(missing_ok=True) + oracle_path = lab.ROOT / 'mods/horizon/src/test/java/dev/horizonlab/parity' / (oracle + '.java') + all_sources = [Path(__file__).resolve(), lab.ROOT / 'tools/oracle_harness.py', lab.ROOT / 'tools/test_rust_parity.py', + lab.ROOT / 'tools/lab.py', oracle_path, lab.ROOT / 'Cargo.toml', lab.ROOT / 'Cargo.lock', + lab.ROOT / 'crates/horizon-client/Cargo.toml', lab.ROOT / 'crates/horizon-client/src/lib.rs', + lab.ROOT / f'crates/horizon-client/examples/{probe}.rs', *map(Path, sources)] + tested = base.source_hashes(all_sources) + input_path, units = make_input(build) + input_hash = lab.digest(input_path, 'sha256') if input_path.is_file() else None + classes, dependencies, _ = compile_oracle(build, oracle, jars, libraries, lock['minecraft']['java_major']) + binary = build_probe(build, probe) + run_logged([binary, input_path, build / 'rust.txt'], build, 'rust') + java_run(build, classes, dependencies, oracle, [input_path, build / 'client.txt'], 'client') + try: + matched = base.compare(build / 'client.txt', build / 'rust.txt') + except AssertionError as error: + raise AssertionError(str(error) + explain(build, str(error))) from None + if expected_lines is not None and matched != expected_lines: + raise AssertionError(f'Incomplete output: {matched} of {expected_lines} lines') + base.ensure_sources_unchanged(all_sources, tested) + if input_hash is not None and input_hash != lab.digest(input_path, 'sha256'): + raise AssertionError('Input fixtures changed') + lab.write_json(report, dict( + schema=1, minecraft=lock['minecraft']['version'], manifest_sha1=lock['minecraft']['manifest_sha1'], + platform=platform.platform(), rustc=subprocess.check_output(['rustc', '--version'], text=True).strip(), + java=subprocess.check_output(['java', '--version'], text=True).splitlines()[0], units=units, + sources_sha256=tested, input_sha256=input_hash, client_jar_sha256=lab.digest(jars['client'], 'sha256'), + matched_output_lines=matched, output_sha256=lab.digest(build / 'rust.txt', 'sha256'), scope=scope)) + print(f'{units:,} {name} cases match the pinned client ({matched:,} output lines): {report}', flush=True) + return matched + + +def explain(build, message): + """Summarise differing sections ("== name" blocks) of multi-case outputs.""" + def sections(path): + out, name = {}, None + for line in path.read_text(encoding='utf-8', errors='replace').splitlines(): + if line.startswith('== '): + name = line[3:] + out[name] = [] + elif name is not None: + out[name].append(line) + return out + left, right = sections(build / 'client.txt'), sections(build / 'rust.txt') + report, count = '', 0 + for name in left: + if left[name] != right.get(name): + count += 1 + if count <= 25: + case = build / 'cases' / name + text = case.read_text(encoding='utf-8', errors='replace') if case.is_file() else '' + a, b = left[name], right.get(name, []) + diffs = [(x, y) for x, y in zip(a, b) if x != y][:4] + if len(a) != len(b): + diffs.append((f'<{len(a)} lines>', f'<{len(b)} lines>')) + report += f"\n case {name}: {text[:300]!r}\n differences (vanilla, rust): {diffs}" + return f'\n{count} differing cases.' + report diff --git a/tools/test_options_parity.py b/tools/test_options_parity.py new file mode 100644 index 000000000..c1c17bf23 --- /dev/null +++ b/tools/test_options_parity.py @@ -0,0 +1,185 @@ +#!/usr/bin/env python3 +"""Compare options.txt loading and saving, and the key mapping table, with the +pinned client: every file is loaded through the real Options.load and written +back with Options.save, and the Rust port must produce identical text.""" +from pathlib import Path +import random +import shutil + +try: + from . import lab, oracle_harness as harness +except ImportError: + import lab, oracle_harness as harness + +VERSION = 5023 + +# Raw JSON-ish value texts: valid, boundary, wrong-typed, lenient-parser and +# syntax-error forms. Syntax errors abort the rest of a load, as in vanilla. +TOKENS = [ + 'true', 'false', 'TRUE', 'False', '"true"', '0', '1', '2', '3', '4', '5', '-1', '-3', '7', '10', '11', '12', '13', + '16', '27', '29', '30', '31', '32', '33', '60', '65', '69', '70', '71', '100', '109', '110', '111', '120', '128', + '129', '130', '255', '256', '260', '261', '1000', '2147483646', '2147483647', '2147483648', '-2147483648', + '0.0', '0.1', '0.25', '0.3', '0.5', '0.75', '0.77', '0.99', '1.0', '1.5', '2.0', '2.5', '5.0', '5.5', '6.0', + '10.0', '10.5', '-0.5', '-0.0', '1e0', '1e1', '1E-2', '1e2', '2.5e-1', '0.0001', '1e30', '12.7', '4.99', + '"fast"', '"fancy"', '"fabulous"', '"custom"', '"afk"', '"minimized"', '"left"', '"right"', '"default"', + '"opengl"', '"all"', '"none"', '"limited"', '"never"', '"pause"', '"pause_and_toast"', '"DEFAULT"', '"FREQUENT"', + '"CONSTANT"', '"false"', '"movement"', '"Fast"', "'fast'", 'fast', 'afk', 'left', 'abc', '', ' ', '""', 'null', + '[]', '[1,2]', '["vanilla"]', '["vanilla","file/x.zip"]', '{}', '[vanilla,a]', '["a&=\'"]', '0.5f', '.5', + '007', '+1', 'NaN', 'Infinity', '-Infinity', '0x10', '1 2', '"unterminated', '{', ']', '1,2', '0.5 # note', + '0.5 // note', '/* c */ 0.5', '0.5;', ')]}\'\n0.5', 'tRuE', 'nul', 'true false', +] +KEY_TOKENS = [ + 'key.keyboard.w', 'key.keyboard.unknown', 'key.mouse.left', 'key.mouse.9', 'key.mouse.99', 'key.keyboard.200', + 'key.keyboard.007', 'key.keyboard.-5', 'key.keyboard.+4', 'key.keyboard.', 'key.keyboard', 'key.mouse', 'key.mousefoo', + 'key.keyboardX5', 'key.keyboard.abc', 'key.keyboard.f13', 'key.keyboard.keypad.0', 'key.keyboard.right.shift', + '', 'w', 'key.w', 'scancode.17', 'key.keyboard.4294967296', 'key.keyboard.2147483647', 'key.keyboard.2147483648', + 'KEY.KEYBOARD.W', 'key.keyboard.menu', 'key.keyboard.f24', +] +PLAIN_TOKENS = ['true', 'false', 'True', '1', '0', 'yes', '', ' true', 'abc', '5', '-1', '2147483648', '+3', '007', '1.0'] +STRING_TOKENS = ['en_us', 'FR_fr', '', ' a:b ', 'a:b:c', 'Ünïcode', '"quoted"', 'x' * 300] +TAIL = 'musicFrequency:"FREQUENT"\nmodelPart_hat:false\n' # shows whether a load was aborted + + +def option_keys(): + """Option-instance keys, read from the Rust table through the probe-independent + list below (generated from VanillaOptionsTableExporter output).""" + return ALL_KEYS + + +# Every key the 26.3 Options writes, in processing order (verified by the +# defaults case: a mismatch in either name or order fails the comparison). +ALL_KEYS = [ + 'ao', 'biomeBlendRadius', 'chunkSectionFadeInTime', 'cutoutLeaves', 'enableVsync', 'entityDistanceScaling', + 'entityShadows', 'forceUnicodeFont', 'japaneseGlyphVariants', 'fov', 'fovEffectScale', 'darknessEffectScale', + 'glintSpeed', 'glintStrength', 'preferredGraphicsBackend', 'graphicsPreset', 'prioritizeChunkUpdates', + 'fullscreen', 'exclusiveFullscreen', 'macFullscreenMenuVisibility', 'gamma', 'guiScale', 'debugGuiScale', + 'maxAnisotropyBit', 'textureFiltering', 'maxFps', 'improvedTransparency', 'inactivityFpsLimit', 'mipmapLevels', + 'narrator', 'particles', 'reducedDebugInfo', 'renderClouds', 'cloudRange', 'renderDistance', + 'simulationDistance', 'screenEffectScale', 'soundDevice', 'vignette', 'weatherRadius', 'autoJump', + 'rotateWithMinecart', 'operatorItemsTab', 'autoSuggestions', 'chatColors', 'chatLinks', 'chatLinksPrompt', + 'discrete_mouse_scroll', 'invertXMouse', 'invertYMouse', 'realmsNotifications', 'showSubtitles', + 'directionalAudio', 'bobView', 'toggleCrouch', 'toggleSprint', 'toggleAttack', 'toggleUse', 'sprintWindow', + 'darkMojangStudiosBackground', 'hideLightningFlashes', 'hideSplashTexts', 'mouseSensitivity', + 'damageTiltStrength', 'highContrast', 'highContrastBlockOutline', 'narratorHotkey', 'resourcePacks', + 'incompatibleResourcePacks', 'lastServer', 'lang', 'chatVisibility', 'chatOpacity', 'chatLineSpacing', + 'textBackgroundOpacity', 'backgroundForChatOnly', 'hideServerAddress', 'advancedItemTooltips', + 'pauseOnLostFocus', 'overrideWidth', 'overrideHeight', 'chatHeightFocused', 'chatDelay', 'chatHeightUnfocused', + 'chatScale', 'chatWidth', 'notificationDisplayTime', 'useNativeTransport', 'mainHand', 'attackIndicator', + 'tutorialStep', 'mouseWheelSensitivity', 'allowCursorChanges', 'quitShortcuts', 'ctrlClickEmulatesRightClick', + 'glDebugVerbosity', 'skipMultiplayerWarning', 'hideMatchedNames', 'joinedFirstServer', 'syncChunkWrites', + 'showAutosaveIndicator', 'allowServerListing', 'inGameNotification', 'sharePresence', 'onlyShowSecureChat', + 'saveChatDrafts', 'panoramaScrollSpeed', 'telemetryOptInExtra', 'onboardAccessibility', + 'menuBackgroundBlurriness', 'startedCleanly', 'musicToast', 'musicFrequency', +] +PLAIN = {'lastServer', 'lang', 'hideServerAddress', 'advancedItemTooltips', 'pauseOnLostFocus', 'overrideWidth', + 'overrideHeight', 'useNativeTransport', 'glDebugVerbosity', 'skipMultiplayerWarning', 'joinedFirstServer', + 'syncChunkWrites', 'onboardAccessibility', 'startedCleanly'} +PLAIN_STRINGS = {'lastServer', 'lang'} +MAPPINGS = None +SOUNDS = ['master', 'music', 'record', 'weather', 'block', 'hostile', 'neutral', 'player', 'ambient', 'voice', 'ui'] +PARTS = ['cape', 'jacket', 'left_sleeve', 'right_sleeve', 'left_pants_leg', 'right_pants_leg', 'hat'] + + +def write(directory, index, text, newline='\n'): + (directory / f'{index:05d}.txt').write_bytes(text.replace('\n', newline).encode('utf-8')) + + +def make_cases(build): + directory = build / 'cases' + shutil.rmtree(directory, ignore_errors=True) + directory.mkdir() + rng = random.Random(0x4f5054) + n = 0 + # The no-file case is named absent.txt so the oracle skips the copy. + (directory / 'absent.txt').write_text('') + n += 1 + header = f'version:{VERSION}\n' + # One option per file with each token: isolates every codec path. + for key in ALL_KEYS: + tokens = PLAIN_TOKENS if key in PLAIN and key not in PLAIN_STRINGS else ( + STRING_TOKENS if key in PLAIN_STRINGS else TOKENS) + for token in tokens: + write(directory, n, f'{header}{key}:{token}\n{TAIL}') + n += 1 + # Round trips of values the game itself would save. + for key in ALL_KEYS: + write(directory, n, f'{header}{key}:{rng.choice(TOKENS)}\n{key}:{rng.choice(TOKENS)}\n') + n += 1 + # Key mappings, sound volumes and model parts. + keys = ['key.attack', 'key.use', 'key.forward', 'key.sneak', 'key.sprint', 'key.hotbar.1', 'key.swapOffhand', + 'key.debug.modifier', 'key.debug.profilingChart', 'key.spectatorHotbar', 'key.nonexistent'] + for key in keys: + for token in KEY_TOKENS: + write(directory, n, f'{header}key_{key}:{token}\n{TAIL}') + n += 1 + for source in SOUNDS + ['nonexistent']: + for token in TOKENS[:60]: + write(directory, n, f'{header}soundCategory_{source}:{token}\n{TAIL}') + n += 1 + for part in PARTS + ['nonexistent']: + for token in PLAIN_TOKENS: + write(directory, n, f'{header}modelPart_{part}:{token}\n') + n += 1 + # Random multi-option files, some with CRLF/CR line ends, noise and duplicates. + syntax_errors = {'1 2', '"unterminated', '{', ']', '1,2', 'true false', '0.5 // note'} + safe = [t for t in TOKENS if t not in syntax_errors] + for _ in range(1500): + lines = [] if rng.random() < 0.1 else [f'version:{VERSION}'] + for _ in range(rng.randrange(1, 40)): + key = rng.choice(ALL_KEYS) + pool = safe if rng.random() < 0.9 else TOKENS + lines.append(f'{key}:{rng.choice(PLAIN_TOKENS if key in PLAIN and key not in PLAIN_STRINGS else pool)}') + if rng.random() < 0.05: + lines.append(rng.choice(['', 'garbage', ':', 'novalue:', ':novalue', 'a:b:c', 'fullscreenResolution:1920x1080@60:24'])) + newline = rng.choice(['\n', '\n', '\r\n', '\r']) + write(directory, n, '\n'.join(lines) + rng.choice(['', '\n']), newline) + n += 1 + # Older files exercise the data fixers; each version boundary of the OPTIONS fixers. + legacy = [ + 'fancyGraphics:true\nao:2\nlang:EN_US\nchatOpacity:0.4\nmenuBackgroundBlurriness:0.5\nkey_key.forward:17\n' + 'key_key.attack:-100\nkey_key.use:-99\nkey_key.pickItem:-98\nkey_key.jump:-95\nresourcePacks:["programer_art"]\n' + 'showNowPlayingToast:true\n', + 'fancyGraphics:false\nao:0\nkey_key.forward:key.w\nkey_key.swapHands:key.f\nmouseSensitivity:0.5\n', + 'graphicsMode:2\nao:1\nmenuBackgroundBlurriness:abc\nchatOpacity:abc\nshowNowPlayingToast:false\n', + 'graphicsMode:0\nmenuBackgroundBlurriness:0.35\nchatOpacity:1e-3\n', + 'graphicsMode:1\nlang:Fr_Ca\nresourcePacks:["a","programer_art"]\nincompatibleResourcePacks:["programer_art"]\n', + 'key_key.forward:abc\n', 'key_key.forward:\n', 'key_key.attack:k\n', 'chatOpacity:Infinity\n', + 'chatOpacity: 0.5d\n', 'menuBackgroundBlurriness:0.25\n', 'menuBackgroundBlurriness:1.04999\n', + ] + versions = [-1, 0, 100, 504, 505, 815, 816, 1343, 1344, 1445, 1446, 1935, 1936, 2555, 2556, 2557, 2558, 3200, 3201, + 3213, 3214, 3318, 3319, 3942, 3943, 4650, 4651, 4660, 4661, 4891, 4892, 5022, 5023, 5024, 9999] + for version in versions: + for body in legacy: + write(directory, n, f'version:{version}\n{body}') + n += 1 + for body in legacy: + write(directory, n, body) + n += 1 + write(directory, n, f'version:abc\n{body}') + n += 1 + write(directory, n, f'version: 5023\n{body}') + n += 1 + for text in ['fullscreenResolution:1920x1080@60:24\n', 'fullscreenResolution:\n', 'fov:abc\nfullscreenResolution:x\n', + 'fov:1 2\nfullscreenResolution:x\n', 'version:5023\nfov:0.5\n', 'FOV:0.5\n', ' fov:0.5\n', 'fov :0.5\n']: + write(directory, n, f'version:{VERSION}\n{text}') + n += 1 + return directory, n + + +def main(): + scope = ('Real Options.load and Options.save (26.3) on generated options.txt files: the full option table in ' + 'processing order with defaults, every codec/validator path (int ranges, quantised doubles, unit doubles with ' + 'boolean alternative, string and id enums with wrapping, clouds, fov, frame limit, scroll sensitivity), plain ' + 'fields, lenient Gson parsing and syntax-error aborts, key mappings (names, scancode-number forms, unbinding), ' + 'sound volumes, model parts, line endings, the OPTIONS data fixers across version boundaries, and the ' + 'KeyMapping table (order, defaults, categories, toggle mappings). Does not cover option screens or ' + 'runtime side effects of setting an option.') + harness.differential( + 'rust-options-parity', 'VanillaOptionsOracle', 'options_probe', make_cases, scope, + sources=[lab.ROOT / 'crates/horizon-client/src/options_file.rs', lab.ROOT / 'crates/horizon-client/src/options_fixes.rs', + lab.ROOT / 'crates/horizon-client/src/java_text.rs', lab.ROOT / 'crates/horizon-client/src/key_names.rs', + lab.ROOT / 'crates/horizon-client/src/keybinds.rs']) + + +if __name__ == '__main__': + main()