Merge pull request #614 from LookImEcho-Rick/codex/fix-world-input-capture

Fix mouse capture after world loading
This commit is contained in:
Ludovic Marie
2026-10-17 08:01:18 +02:00
committed by GitHub
3 changed files with 171 additions and 0 deletions
+15
View File
@@ -3104,6 +3104,7 @@ impl Game<'_> {
self.eye = 1.62;
self.previous_eye = 1.62;
self.clock.reset();
self.capture_loaded_world();
Ok(())
}
fn tick(&mut self) -> Result<()> {
@@ -3661,6 +3662,10 @@ impl Game<'_> {
) || self.book.is_some())
}
fn capture(&mut self, capture: bool) {
// MouseHandler.grabMouse never captures an inactive window.
if capture && !self.focused {
return;
}
if !capture {
self.stop_mining();
}
@@ -3679,6 +3684,16 @@ impl Game<'_> {
}
window.set_cursor_visible(!self.captured);
}
/// LevelLoadingScreen.onClose -> Gui.setScreen(null) -> grabMouse.
fn capture_loaded_world(&mut self) {
// Loading may finish after focus was lost or another screen opened.
if self.title.is_none()
&& self.screen == Screen::Playing
&& !self.remote.as_ref().is_some_and(|r| r.chat_input.is_some())
{
self.capture(true);
}
}
fn draw_item(&mut self, batch: &mut HudBatch, stack: &ItemStack, x: f32, y: f32) {
// `GuiGraphics.renderItem`: the resolved item model (tints, foil and
// special renderers included), then the decorations.
+1
View File
@@ -1918,6 +1918,7 @@ impl Game<'_> {
if let Some(r) = self.remote.as_mut() {
r.loaded_sent = true;
}
self.capture_loaded_world();
}
let stick = self.pad_move();
let Some(player) = self.player.as_mut() else {
+155
View File
@@ -0,0 +1,155 @@
"""Exercise the client's capture methods without opening or focusing an OS window.
The fixture substitutes only winit and mouse state. Method bodies come from the
client, so the assertions observe grab attempts, visibility and stored capture
state. Native Windows delivery remains a manual check. Vanilla 26.3 reference:
LevelLoadingScreen.tick/onClose, Gui.setScreen, MouseHandler.grabMouse/releaseMouse.
"""
from pathlib import Path
import os
import shutil
import subprocess
import tempfile
import unittest
ROOT = Path(__file__).resolve().parents[1]
def method(source, name):
start = source.index(f" fn {name}(")
opening = source.index("{", start)
depth = 1
end = opening + 1
while depth:
depth += (source[end] == "{") - (source[end] == "}")
end += 1
return source[start:end]
class WorldInputCaptureTests(unittest.TestCase):
def test_loading_completion_wiring(self):
game = (ROOT / "crates/horizon-client/src/game.rs").read_text(encoding="utf-8")
remote = (ROOT / "crates/horizon-client/src/game/remote.rs").read_text(encoding="utf-8")
spawn = method(game, "spawn_player")
self.assertLess(spawn.index("self.player = Some(player)"),
spawn.index("self.capture_loaded_world()"))
tick = remote[remote.index(" pub(super) fn tick_remote("):]
ready = tick[tick.index("if self.remote.as_ref().is_some_and(|r| !r.loaded_sent)"):]
self.assertLess(ready.index("r.loaded_sent = true"),
ready.index("self.capture_loaded_world()"))
self.assertLess(ready.index("self.capture_loaded_world()"),
ready.index("let stick = self.pad_move()"))
@unittest.skipUnless(shutil.which("rustc"), "requires Rust")
def test_capture_lifecycle(self):
source = (ROOT / "crates/horizon-client/src/game.rs").read_text(encoding="utf-8")
fixture = r'''
use std::cell::Cell;
#[derive(Clone, Copy, PartialEq)]
enum Screen { Playing, Paused, Inventory }
enum CursorGrabMode { Locked, Confined, None }
#[derive(Default)]
struct Window { grabs: Cell<u32>, visible: Cell<bool>, fail: bool }
impl Window {
fn set_cursor_grab(&self, mode: CursorGrabMode) -> Result<(), ()> {
if !matches!(mode, CursorGrabMode::None) {
self.grabs.set(self.grabs.get() + 1);
}
if self.fail { Err(()) } else { Ok(()) }
}
fn set_cursor_visible(&self, visible: bool) { self.visible.set(visible); }
}
#[derive(Default)]
struct Mouse { ignore_first: bool }
impl Mouse { fn set_ignore_first_move(&mut self) { self.ignore_first = true; } }
struct Remote { chat_input: Option<()> }
struct Game {
focused: bool, agent_pointer: bool, window: Option<Window>, mouse: Mouse,
captured: bool, title: Option<()>, screen: Screen, remote: Option<Remote>,
mining: bool,
}
impl Default for Game {
fn default() -> Self {
Self { focused: true, agent_pointer: false, window: Some(Window::default()),
mouse: Mouse::default(), captured: false, title: None,
screen: Screen::Playing, remote: None, mining: false }
}
}
impl Game {
fn stop_mining(&mut self) { self.mining = false; }
METHODS
}
fn main() {
// New and existing worlds, returning to title, and reopening a world.
for remote in [false, true] {
let mut game = Game::default();
if remote { game.remote = Some(Remote { chat_input: None }); }
for _ in 0..3 {
game.title = Some(());
game.capture(false);
game.capture_loaded_world();
assert!(!game.captured);
game.title = None;
game.capture_loaded_world();
assert!(game.captured);
assert!(game.mouse.ignore_first);
assert!(!game.window.as_ref().unwrap().visible.get());
for screen in [Screen::Paused, Screen::Inventory] {
game.screen = screen;
game.mining = true;
game.capture(false);
assert!(!game.mining);
game.capture_loaded_world();
assert!(!game.captured);
assert!(game.window.as_ref().unwrap().visible.get());
game.screen = Screen::Playing;
game.capture(true);
assert!(game.captured);
}
}
// Alt+Tab during loading: no native grab or agent-pointer reset.
game.focused = false;
game.mining = true;
game.capture(false);
assert!(!game.mining);
assert!(!game.captured);
assert!(game.window.as_ref().unwrap().visible.get());
game.agent_pointer = true;
let grabs = game.window.as_ref().unwrap().grabs.get();
game.capture_loaded_world();
game.capture(true);
assert!(!game.captured);
assert!(game.agent_pointer);
assert_eq!(game.window.as_ref().unwrap().grabs.get(), grabs);
game.focused = true;
assert!(!game.captured); // Focus alone does not resume gameplay.
game.capture(true); // Click or resume action.
assert!(game.captured);
}
let mut game = Game::default();
game.remote = Some(Remote { chat_input: Some(()) });
game.capture_loaded_world();
assert!(!game.captured);
assert_eq!(game.window.as_ref().unwrap().grabs.get(), 0);
game.remote = None;
game.window.as_mut().unwrap().fail = true;
game.capture_loaded_world();
assert!(!game.captured);
assert!(game.window.as_ref().unwrap().visible.get());
}
'''
fixture = fixture.replace("METHODS", method(source, "capture") + "\n" +
method(source, "capture_loaded_world"))
with tempfile.TemporaryDirectory(prefix="horizon-input-") as folder:
folder = Path(folder)
rust = folder / "capture.rs"
binary = folder / ("capture.exe" if os.name == "nt" else "capture")
rust.write_text(fixture, encoding="utf-8")
subprocess.run(["rustc", "--edition=2024", str(rust), "-o", str(binary)],
check=True, capture_output=True, text=True, timeout=60)
subprocess.run([str(binary)], check=True, capture_output=True, text=True, timeout=10)
if __name__ == "__main__":
unittest.main()