diff --git a/crates/horizon-client/examples/toggle_keys_probe.rs b/crates/horizon-client/examples/toggle_keys_probe.rs new file mode 100644 index 000000000..01ef5fd4d --- /dev/null +++ b/crates/horizon-client/examples/toggle_keys_probe.rs @@ -0,0 +1,56 @@ +#![forbid(unsafe_code)] +//! Runs tools/test_toggle_keys_parity.py's event sequences through +//! `ToggleKeys`, the sneak/sprint/attack/use toggle mappings. +use horizon_client::{ + Result, + keymapping::{KeyAction, ToggleKeys}, +}; +use serde_json::Value; +use std::{ + fs::File, + io::{BufRead, BufReader, BufWriter, Write}, +}; + +fn main() -> Result<()> { + let args: Vec = std::env::args().collect(); + let input = BufReader::new(File::open(&args[1])?); + let mut out = BufWriter::new(File::create(&args[2])?); + for (n, line) in input.lines().enumerate() { + let c: Value = serde_json::from_str(&line?)?; + writeln!(out, "== {n}")?; + let mut keys = ToggleKeys::default(); + let mut options = [false; 4]; + for op in c["ops"].as_array().unwrap() { + let name = op[0].as_str().unwrap(); + let slot = || op[1].as_u64().unwrap() as usize; + match name { + "option" => options[slot()] = op[2].as_bool().unwrap(), + "key" => { + let action = match op[2].as_i64().unwrap() { + 0 => KeyAction::Release, + 1 => KeyAction::Press, + _ => KeyAction::Repeat, + }; + keys.key(slot(), action, op[3].as_bool().unwrap(), options[slot()]); + } + "button" => keys.button( + slot(), + op[2].as_bool().unwrap(), + op[3].as_bool().unwrap(), + options[slot()], + ), + "open" => keys.screen_opened(options), + "close" => keys.screen_closed(options), + "respawn" => keys.respawn(), + other => panic!("{other}"), + } + let mut line = name.to_string(); + for k in &keys.0 { + line += &format!(" {} {}", k.is_down, k.pending_clicks()); + } + writeln!(out, "{line}")?; + } + } + out.flush()?; + Ok(()) +} diff --git a/crates/horizon-client/src/game.rs b/crates/horizon-client/src/game.rs index d9f77d66b..54876c5bf 100644 --- a/crates/horizon-client/src/game.rs +++ b/crates/horizon-client/src/game.rs @@ -108,7 +108,7 @@ use horizon_client::{ gfx::{Frame, Renderer}, hud::{HudAtlas, HudBatch, rgba}, items::{ItemStack, Items}, - keymapping::KeyState, + keymapping::KeyAction, light::LightTables, mesher::{MeshTables, Vertex}, mobs::{Mob, MobType, MobTypes}, @@ -567,7 +567,7 @@ struct Game<'a> { /// `Options.smoothCamera` (cinematic camera), not persisted. smooth_camera: bool, /// Sneak, sprint, attack and use as ToggleKeyMappings. - toggles: [KeyState; 4], + toggles: horizon_client::keymapping::ToggleKeys, /// A world screen with the pointer captured was open last frame. was_playing: bool, /// Minecraft.pause: a single-player screen that pauses the game is open. @@ -2745,7 +2745,7 @@ impl Game<'_> { /// Keep the held-key state of toggled sneak and sprint in step with their mapping. fn sync_toggle(&mut self, slot: usize) { let key = [KeyCode::ShiftLeft, KeyCode::ControlLeft][slot]; - if self.toggles[slot].is_down { + if self.toggles.is_down(slot) { self.keys.insert(key); } else { self.keys.remove(&key); @@ -2765,20 +2765,15 @@ impl Game<'_> { self.settings.toggle_attack, self.settings.toggle_use, ]; - for (slot, option) in options.into_iter().enumerate() { - if playing { - if self.toggles[slot].should_restore_state_on_screen_closed(option) { - self.toggles[slot].set_down(true, option); - } - } else { - self.toggles[slot].release(option); - } - match slot { - 0 | 1 => self.sync_toggle(slot), - 2 => self.left = self.toggles[2].is_down, - _ => self.right = self.toggles[3].is_down, - } + if playing { + self.toggles.screen_closed(options); + } else { + self.toggles.screen_opened(options); } + self.sync_toggle(0); + self.sync_toggle(1); + self.left = self.toggles.is_down(2); + self.right = self.toggles.is_down(3); } /// `MouseHandler.handleAccumulatedMovement` and `Entity.turn`, once per frame. fn apply_mouse_look(&mut self) { @@ -7681,15 +7676,16 @@ impl Game<'_> { if pressed && self.attack() { return Ok(()); } - self.toggles[2].set_down(pressed, self.settings.toggle_attack); - self.left = self.toggles[2].is_down; + self.toggles + .button(2, pressed, false, self.settings.toggle_attack); + self.left = self.toggles.is_down(2); if pressed { self.destroy_delay = 0; } } MouseButton::Right => { - self.toggles[3].set_down(pressed, self.settings.toggle_use); - self.right = self.toggles[3].is_down; + self.toggles.button(3, pressed, false, self.settings.toggle_use); + self.right = self.toggles.is_down(3); if pressed { self.use_item()?; self.use_delay = 4; @@ -8141,18 +8137,23 @@ impl ApplicationHandler for Game<'_> { } None => return Ok(()), }; - // Sneak and sprint are ToggleKeyMappings: a press flips them when toggling. + // Sneak and sprint are ToggleKeyMappings: a press (or a key + // repeat) flips them when toggling; only releases reach them + // behind a screen (KeyboardHandler.keyPress). let toggle = match key { KeyCode::ShiftLeft => Some((0, self.settings.toggle_crouch)), KeyCode::ControlLeft => Some((1, self.settings.toggle_sprint)), _ => None, }; if let Some((slot, option)) = toggle { - if !event.repeat { - self.toggles[slot] - .set_down(event.state == ElementState::Pressed, option); - self.sync_toggle(slot); - } + let action = match (event.state, event.repeat) { + (ElementState::Released, _) => KeyAction::Release, + (_, false) => KeyAction::Press, + (_, true) => KeyAction::Repeat, + }; + let screen_open = self.screen != Screen::Playing || self.title.is_some(); + self.toggles.key(slot, action, screen_open, option); + self.sync_toggle(slot); if event.state != ElementState::Pressed { return Ok(()); } @@ -8460,12 +8461,7 @@ pub fn run() -> Result<()> { focused: true, mouse: MouseLook::default(), smooth_camera: false, - toggles: [ - KeyState::toggle(true, true), - KeyState::toggle(true, true), - KeyState::toggle(true, false), - KeyState::toggle(false, false), - ], + toggles: Default::default(), was_playing: false, pause: false, debug: false, diff --git a/crates/horizon-client/src/game/screens.rs b/crates/horizon-client/src/game/screens.rs index b98c4ac7f..d82c1d0d6 100644 --- a/crates/horizon-client/src/game/screens.rs +++ b/crates/horizon-client/src/game/screens.rs @@ -213,9 +213,12 @@ impl Game<'_> { match hit { Some(0) if self.remote.is_some() => { self.ui.death_text = None; + self.toggles.respawn(); self.remote_respawn(); } Some(0) => { + // LocalPlayer.respawn: KeyMapping.resetToggleKeys. + self.toggles.respawn(); self.respawn_out_of_end()?; self.player = None; self.screen = Screen::Playing; diff --git a/crates/horizon-client/src/keymapping.rs b/crates/horizon-client/src/keymapping.rs index 157e59cb8..e598fbf71 100644 --- a/crates/horizon-client/src/keymapping.rs +++ b/crates/horizon-client/src/keymapping.rs @@ -74,6 +74,10 @@ impl KeyState { pub fn reset(&mut self) { self.is_down = false; } + /// Clicks not yet consumed. + pub fn pending_clicks(&self) -> i32 { + self.click_count + } /// `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 { @@ -85,6 +89,90 @@ impl KeyState { } } +/// A keyboard event (`KeyEvent.Action`): SDL reports a held key's repeats +/// as their own action. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum KeyAction { + Release, + Press, + Repeat, +} + +/// Sneak. +pub const SNEAK: usize = 0; +/// Sprint. +pub const SPRINT: usize = 1; +/// Attack (mouse). +pub const ATTACK: usize = 2; +/// Use (mouse). +pub const USE: usize = 3; + +/// The `ToggleKeyMapping`s `Options` builds: sneak and sprint (keyboard, +/// restored after a screen), attack (mouse, restored) and use (mouse, not +/// restored), and the handlers that drive them. `needs_toggle` is each +/// mapping's toggle option, read at every event as vanilla does. +#[derive(Clone, Debug)] +pub struct ToggleKeys(pub [KeyState; 4]); +impl Default for ToggleKeys { + fn default() -> Self { + Self([ + KeyState::toggle(true, true), + KeyState::toggle(true, true), + KeyState::toggle(true, false), + KeyState::toggle(false, false), + ]) + } +} +impl ToggleKeys { + pub fn is_down(&self, slot: usize) -> bool { + self.0[slot].is_down + } + /// `KeyboardHandler.keyPress` for a key bound to `slot`: a release sets + /// the mapping up (`KeyMapping.set(key, false)`); a press or a repeat + /// with no screen open sets it down and clicks it. + pub fn key(&mut self, slot: usize, action: KeyAction, screen_open: bool, needs_toggle: bool) { + match action { + KeyAction::Release => self.0[slot].set_down(false, needs_toggle), + KeyAction::Press | KeyAction::Repeat if !screen_open => { + self.0[slot].set_down(true, needs_toggle); + self.0[slot].click(); + } + _ => {} + } + } + /// `MouseHandler.onButton` for a button bound to `slot`: only without a + /// screen or overlay. + pub fn button(&mut self, slot: usize, pressed: bool, screen_open: bool, needs_toggle: bool) { + if !screen_open { + self.0[slot].set_down(pressed, needs_toggle); + if pressed { + self.0[slot].click(); + } + } + } + /// `Gui.setScreen` with a screen: `KeyMapping.releaseAll`. + pub fn screen_opened(&mut self, needs_toggle: [bool; 4]) { + for (key, option) in self.0.iter_mut().zip(needs_toggle) { + key.release(option); + } + } + /// `Gui.setScreen(null)` in a level: + /// `KeyMapping.restoreToggleStatesOnScreenClosed`. + pub fn screen_closed(&mut self, needs_toggle: [bool; 4]) { + for (key, option) in self.0.iter_mut().zip(needs_toggle) { + if key.should_restore_state_on_screen_closed(option) { + key.set_down(true, option); + } + } + } + /// `LocalPlayer.respawn`: `KeyMapping.resetToggleKeys`. + pub fn respawn(&mut self) { + for key in &mut self.0 { + key.reset(); + } + } +} + #[cfg(test)] mod tests { use super::*; @@ -99,6 +187,19 @@ mod tests { assert!(!k.is_down); } #[test] + fn screens_block_presses_but_not_releases() { + let mut keys = ToggleKeys::default(); + keys.key(SNEAK, KeyAction::Press, true, false); + assert!(!keys.is_down(SNEAK)); + keys.key(SNEAK, KeyAction::Press, false, false); + assert!(keys.is_down(SNEAK)); + keys.key(SNEAK, KeyAction::Release, true, false); + assert!(!keys.is_down(SNEAK)); + keys.key(SPRINT, KeyAction::Press, false, true); + keys.respawn(); + assert!(!keys.is_down(SPRINT)); + } + #[test] fn screen_release_restores_toggled_state() { let mut k = KeyState::toggle(true, true); k.set_down(true, true); diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaToggleKeysOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaToggleKeysOracle.java new file mode 100644 index 000000000..ae3e34519 --- /dev/null +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaToggleKeysOracle.java @@ -0,0 +1,102 @@ +package dev.horizonlab.parity; + +import com.google.gson.*; +import com.mojang.blaze3d.platform.InputConstants; +import java.io.*; +import java.lang.reflect.*; +import java.nio.charset.StandardCharsets; +import java.nio.file.*; +import java.util.*; +import net.minecraft.client.*; + +/** + * Drives the real Options key mappings (keyShift, keySprint, keyAttack and + * keyUse are ToggleKeyMappings reading toggleCrouch/toggleSprint/toggleAttack/ + * toggleUse) through the real static KeyMapping.set/click, releaseAll, + * restoreToggleStatesOnScreenClosed and resetToggleKeys, dispatched as + * KeyboardHandler.keyPress, MouseHandler.onButton, Gui.setScreen and + * LocalPlayer.respawn call them, and prints each mapping's down state and + * pending clicks after every event. + */ +public final class VanillaToggleKeysOracle { + static Field field(Class type, String name) throws Exception { + Field f = type.getDeclaredField(name); + f.setAccessible(true); + return f; + } + + 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 unsafe = field(u, "theUnsafe").get(null); + Minecraft shell = (Minecraft) u.getMethod("allocateInstance", Class.class).invoke(unsafe, Minecraft.class); + field(Minecraft.class, "fixerUpper").set(shell, net.minecraft.util.datafix.DataFixers.getDataFixer()); + field(Minecraft.class, "instance").set(null, shell); + Options options = new Options(shell, Files.createTempDirectory("opts").toFile()); + KeyMapping[] mappings = {options.keyShift, options.keySprint, options.keyAttack, options.keyUse}; + List> toggles = List.of(options.toggleCrouch(), options.toggleSprint(), options.toggleAttack(), options.toggleUse()); + Field keyField = field(KeyMapping.class, "key"); + Field clicks = field(KeyMapping.class, "clickCount"); + try (var out = new PrintWriter(Files.newBufferedWriter(Path.of(args[1]), StandardCharsets.UTF_8)); + var lines = Files.lines(Path.of(args[0]))) { + int n = 0; + for (var line : (Iterable) lines::iterator) { + var c = JsonParser.parseString(line).getAsJsonObject(); + out.println("== " + n++); + // A fresh session: everything up, no pending clicks or remembered releases. + for (int i = 0; i < 4; i++) { + toggles.get(i).set(false); + } + KeyMapping.resetToggleKeys(); + KeyMapping.releaseAll(); + KeyMapping.restoreToggleStatesOnScreenClosed(); + for (var m : mappings) { + while (m.consumeClick()) { + } + } + for (var e : c.getAsJsonArray("ops")) { + var op = e.getAsJsonArray(); + String name = op.get(0).getAsString(); + switch (name) { + case "option" -> toggles.get(op.get(1).getAsInt()).set(op.get(2).getAsBoolean()); + case "key" -> { + // KeyboardHandler.keyPress: action 0 releases; a press (1) or an SDL + // repeat (-1) sets and clicks only with no screen open. + var key = (InputConstants.Key) keyField.get(mappings[op.get(1).getAsInt()]); + int action = op.get(2).getAsInt(); + boolean screen = op.get(3).getAsBoolean(); + if (action == 0) { + KeyMapping.set(key, false); + } else if (!screen) { + KeyMapping.set(key, true); + KeyMapping.click(key); + } + } + case "button" -> { + // MouseHandler.onButton: only with no screen or overlay. + var key = (InputConstants.Key) keyField.get(mappings[op.get(1).getAsInt()]); + boolean pressed = op.get(2).getAsBoolean(); + if (!op.get(3).getAsBoolean()) { + KeyMapping.set(key, pressed); + if (pressed) { + KeyMapping.click(key); + } + } + } + case "open" -> KeyMapping.releaseAll(); + case "close" -> KeyMapping.restoreToggleStatesOnScreenClosed(); + case "respawn" -> KeyMapping.resetToggleKeys(); + default -> throw new IllegalArgumentException(name); + } + var sb = new StringBuilder(name); + for (var m : mappings) { + sb.append(' ').append(m.isDown()).append(' ').append(clicks.getInt(m)); + } + out.println(sb); + } + } + } + System.exit(0); + } +} diff --git a/tools/test_toggle_keys_parity.py b/tools/test_toggle_keys_parity.py new file mode 100644 index 000000000..a5d2b0500 --- /dev/null +++ b/tools/test_toggle_keys_parity.py @@ -0,0 +1,76 @@ +#!/usr/bin/env python3 +"""Compare toggle sprint/sneak (and toggle attack/use) with the pinned client: +the real Options ToggleKeyMappings driven by the real static KeyMapping +functions as keyboard presses, SDL key repeats and releases, mouse buttons, +screens opening and closing over the game (releaseAll and +restoreToggleStatesOnScreenClosed), respawning (resetToggleKeys) and toggle +options changing mid-sequence, event by event.""" +import json +import random + +try: + from . import lab, oracle_harness as harness +except ImportError: + import lab, oracle_harness as harness + + +def op(rng, screen): + kind = rng.choice(['key', 'key', 'key', 'key', 'button', 'button', 'open', 'close', 'option', 'option', 'respawn']) + if kind == 'key': + return ['key', rng.choice([0, 1]), rng.choice([1, 1, 0, 0, -1]), screen] + if kind == 'button': + return ['button', rng.choice([2, 3]), rng.random() < 0.5, screen] + if kind == 'option': + return ['option', rng.randrange(4), rng.random() < 0.6] + return [kind] + + +def cases(rng): + # Every short sequence of the main events for sneak with toggle off and on. + events = [['key', 0, 1, False], ['key', 0, 0, False], ['key', 0, -1, False], ['key', 0, 1, True], ['key', 0, 0, True], + ['open'], ['close'], ['respawn'], ['option', 0, True], ['option', 0, False]] + for a in events: + for b in events: + for c in events: + for toggled in (False, True): + yield dict(ops=[['option', 0, toggled], a, b, c, ['key', 0, 1, False], ['open'], ['close']]) + for _ in range(6000): + screen = False + ops = [['option', i, rng.random() < 0.5] for i in range(4)] + for _ in range(rng.randrange(1, 60)): + o = op(rng, screen) + if o[0] == 'open': + screen = True + elif o[0] == 'close': + screen = False + elif o[0] in ('key', 'button'): + o[3] = screen + ops.append(o) + yield dict(ops=ops) + + +def make_cases(build): + path = build / 'cases.jsonl' + count = 0 + with path.open('w') as out: + for case in cases(random.Random(0x544f474c)): + out.write(json.dumps(case, separators=(',', ':')) + '\n') + count += 1 + return path, count + + +def main(): + scope = ('The real Options keyShift/keySprint/keyAttack/keyUse ToggleKeyMappings with their real toggle options and ' + 'shouldRestore flags, driven through the real static KeyMapping.set/click (every mapping bound to the key), ' + 'releaseAll, restoreToggleStatesOnScreenClosed and resetToggleKeys, dispatched as KeyboardHandler.keyPress ' + '(release always; press and SDL repeat only without a screen), MouseHandler.onButton (only without a screen), ' + 'Gui.setScreen and LocalPlayer.respawn call them. Compares down state and pending clicks after every event. ' + 'The screen-consumed keyPressed/keyReleased branches and KeyMapping.setAll (an InputQuirks platform quirk) are ' + 'not exercised; KeyboardInput then reads isDown as the sprint and local input harnesses compare.') + harness.differential( + 'rust-toggle-keys-parity', 'VanillaToggleKeysOracle', 'toggle_keys_probe', make_cases, scope, + sources=[lab.ROOT / 'crates/horizon-client/src/keymapping.rs']) + + +if __name__ == '__main__': + main()