Drive toggle sprint/sneak as vanilla's key handlers do and compare

ToggleKeys holds the sneak, sprint, attack and use ToggleKeyMappings with
the dispatch of KeyboardHandler.keyPress (releases always reach them;
presses and SDL key repeats only without a screen), MouseHandler.onButton,
Gui.setScreen (releaseAll / restoreToggleStatesOnScreenClosed) and
LocalPlayer.respawn (resetToggleKeys, which Horizon lacked). Presses behind
a screen no longer flip a toggled key. tools/test_toggle_keys_parity.py
drives the real Options mappings through the real static KeyMapping
functions (8,000 sequences).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-10 22:12:23 +02:00
parent 538347007a
commit 17ac24f4db
6 changed files with 366 additions and 32 deletions
@@ -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<String> = 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(())
}
+28 -32
View File
@@ -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,
@@ -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;
+101
View File
@@ -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);
@@ -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<OptionInstance<Boolean>> 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<String>) 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);
}
}
+76
View File
@@ -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()